






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  __UpperCAmelCase						:







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







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    parent
									_SCREAMING_SNAKE_CASE       =    batch_size
									_SCREAMING_SNAKE_CASE       =    is_training
									_SCREAMING_SNAKE_CASE       =    use_labels
									_SCREAMING_SNAKE_CASE       =    num_labels
									_SCREAMING_SNAKE_CASE       =    image_size
									_SCREAMING_SNAKE_CASE       =    num_frames
									_SCREAMING_SNAKE_CASE       =    tubelet_size
									_SCREAMING_SNAKE_CASE       =    num_channels
									_SCREAMING_SNAKE_CASE       =    hidden_size
									_SCREAMING_SNAKE_CASE       =    num_hidden_layers
									_SCREAMING_SNAKE_CASE       =    num_attention_heads
									_SCREAMING_SNAKE_CASE       =    intermediate_size
									_SCREAMING_SNAKE_CASE       =    hidden_act
									_SCREAMING_SNAKE_CASE       =    hidden_dropout_prob
									_SCREAMING_SNAKE_CASE       =    attention_probs_dropout_prob
									_SCREAMING_SNAKE_CASE       =    initializer_range
									_SCREAMING_SNAKE_CASE       =    layer_norm_eps
									_SCREAMING_SNAKE_CASE       =    qkv_bias
									_SCREAMING_SNAKE_CASE       =    scope

									_SCREAMING_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 				UpperCamelCase (      self:    Tuple	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    floats_tensor(
									    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]	)

									_SCREAMING_SNAKE_CASE       =    None
									if self.use_labels:
															_SCREAMING_SNAKE_CASE       =    ids_tensor([self.batch_size] ,      self.num_labels	)

									_SCREAMING_SNAKE_CASE       =    self.get_config()

									return config, pixel_values, labels







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







									'''simple docstring'''




									_SCREAMING_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 ,      )
									_SCREAMING_SNAKE_CASE       =    self.num_labels
									return config







			def 				UpperCamelCase (      self:    str ,      UpperCAmelCase_:    Optional[int] ,      UpperCAmelCase_:    int ,      UpperCAmelCase_:    Tuple	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    VivitModel(config=lowercase__	)
									model.to(lowercase__	)
									model.eval()
									_SCREAMING_SNAKE_CASE       =    model(lowercase__	)
									self.parent.assertEqual(result.last_hidden_state.shape ,      (self.batch_size, self.seq_length, self.hidden_size)	)







			def 				UpperCamelCase (      self:    Any ,      UpperCAmelCase_:    Dict ,      UpperCAmelCase_:    Tuple ,      UpperCAmelCase_:    Optional[Any]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    VivitForVideoClassification(lowercase__	)
									model.to(lowercase__	)
									model.eval()

									_SCREAMING_SNAKE_CASE       =    model(lowercase__	)

									# verify the logits shape
									_SCREAMING_SNAKE_CASE       =    torch.Size((self.batch_size, self.num_labels)	)
									self.parent.assertEqual(result.logits.shape ,      lowercase__	)







			def 				UpperCamelCase (      self:    Optional[Any]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.prepare_config_and_inputs()
									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    config_and_inputs
									_SCREAMING_SNAKE_CASE       =    {"""pixel_values""": pixel_values}
									return config, inputs_dict



@require_torch
class  __UpperCAmelCase						(_UpperCAmelCase			,unittest.TestCase       ):
			__snake_case							: str							=				(VivitModel, VivitForVideoClassification) if is_torch_available() else ()

			__snake_case							: Union[str, Any]							=				False
			__snake_case							: Optional[Any]							=				False
			__snake_case							: str							=				False
			__snake_case							: Any							=				False







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







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    VivitModelTester(self	)
									_SCREAMING_SNAKE_CASE       =    ConfigTester(self ,      config_class=lowercase__ ,      has_text_modality=lowercase__ ,      hidden_size=37	)







			def 				UpperCamelCase (      self:    List[Any] ,      UpperCAmelCase_:    Union[str, Any] ,      UpperCAmelCase_:    int ,      UpperCAmelCase_:    Tuple=False	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    copy.deepcopy(lowercase__	)

									if return_labels:
															if model_class in get_values(lowercase__	):
																					_SCREAMING_SNAKE_CASE       =    torch.zeros(
																					    self.model_tester.batch_size ,      dtype=torch.long ,      device=lowercase__	)

									return inputs_dict







			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									self.config_tester.run_common_tests()







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







									'''simple docstring'''




									pass







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()

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







			def 				UpperCamelCase (      self:    Dict	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE       =    model_class(lowercase__	)
															_SCREAMING_SNAKE_CASE       =    inspect.signature(model.forward	)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															_SCREAMING_SNAKE_CASE       =    [*signature.parameters.keys()]

															_SCREAMING_SNAKE_CASE       =    ["""pixel_values""", """head_mask"""]
															self.assertListEqual(arg_names[:2] ,      lowercase__	)







			def 				UpperCamelCase (      self:    List[str]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowercase__	)







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_video_classification(*lowercase__	)







			@slow
			def 				UpperCamelCase (      self:    Optional[int]	):







									'''simple docstring'''




									for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_SCREAMING_SNAKE_CASE       =    VivitModel.from_pretrained(lowercase__	)
															self.assertIsNotNone(lowercase__	)







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()
									_SCREAMING_SNAKE_CASE       =    True

									for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE       =    self.model_tester.seq_length

															_SCREAMING_SNAKE_CASE       =    True
															_SCREAMING_SNAKE_CASE       =    False
															_SCREAMING_SNAKE_CASE       =    True
															_SCREAMING_SNAKE_CASE       =    model_class(lowercase__	)
															model.to(lowercase__	)
															model.eval()
															with torch.no_grad():
																					_SCREAMING_SNAKE_CASE       =    model(**self._prepare_for_class(lowercase__ ,      lowercase__	)	)
															_SCREAMING_SNAKE_CASE       =    outputs.attentions
															self.assertEqual(len(lowercase__	) ,      self.model_tester.num_hidden_layers	)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															_SCREAMING_SNAKE_CASE       =    True
															_SCREAMING_SNAKE_CASE       =    model_class(lowercase__	)
															model.to(lowercase__	)
															model.eval()
															with torch.no_grad():
																					_SCREAMING_SNAKE_CASE       =    model(**self._prepare_for_class(lowercase__ ,      lowercase__	)	)
															_SCREAMING_SNAKE_CASE       =    outputs.attentions
															self.assertEqual(len(lowercase__	) ,      self.model_tester.num_hidden_layers	)

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

															# Check attention is always last and order is fine
															_SCREAMING_SNAKE_CASE       =    True
															_SCREAMING_SNAKE_CASE       =    True
															_SCREAMING_SNAKE_CASE       =    model_class(lowercase__	)
															model.to(lowercase__	)
															model.eval()
															with torch.no_grad():
																					_SCREAMING_SNAKE_CASE       =    model(**self._prepare_for_class(lowercase__ ,      lowercase__	)	)

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

															_SCREAMING_SNAKE_CASE       =    outputs.attentions

															self.assertEqual(len(lowercase__	) ,      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 				UpperCamelCase (      self:    Union[str, Any]	):







									'''simple docstring'''




									def check_hidden_states_output(UpperCAmelCase_:    Union[str, Any] ,      UpperCAmelCase_:    int ,      UpperCAmelCase_:    List[str]	):
															_SCREAMING_SNAKE_CASE       =    model_class(lowercase__	)
															model.to(lowercase__	)
															model.eval()

															with torch.no_grad():
																					_SCREAMING_SNAKE_CASE       =    model(**self._prepare_for_class(lowercase__ ,      lowercase__	)	)

															_SCREAMING_SNAKE_CASE       =    outputs.hidden_states
															_SCREAMING_SNAKE_CASE       =    self.model_tester.num_hidden_layers + 1
															self.assertEqual(len(lowercase__	) ,      lowercase__	)

															_SCREAMING_SNAKE_CASE       =    self.model_tester.seq_length

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

									_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE       =    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE       =    True
															check_hidden_states_output(lowercase__ ,      lowercase__ ,      lowercase__	)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															_SCREAMING_SNAKE_CASE       =    True

															check_hidden_states_output(lowercase__ ,      lowercase__ ,      lowercase__	)







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







									'''simple docstring'''




									pass

def 			__lowerCamelCase     (						)				->    Optional[int]:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE       =    hf_hub_download(
						    repo_id="""hf-internal-testing/spaghetti-video"""			,filename="""eating_spaghetti_32_frames.npy"""			,repo_type="""dataset"""						)
						_SCREAMING_SNAKE_CASE       =    np.load(snake_case__						)
						return list(snake_case__						)




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







			@cached_property
			def 				UpperCamelCase (      self:    Tuple	):







									'''simple docstring'''




									return VivitImageProcessor() if is_vision_available() else None







			@slow
			def 				UpperCamelCase (      self:    Optional[Any]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    VivitForVideoClassification.from_pretrained("""google/vivit-b-16x2-kinetics400"""	).to(lowercase__	)

									_SCREAMING_SNAKE_CASE       =    self.default_image_processor
									_SCREAMING_SNAKE_CASE       =    prepare_video()
									_SCREAMING_SNAKE_CASE       =    image_processor(lowercase__ ,      return_tensors="""pt"""	).to(lowercase__	)

									# forward pass
									with torch.no_grad():
															_SCREAMING_SNAKE_CASE       =    model(**lowercase__	)

									# verify the logits
									_SCREAMING_SNAKE_CASE       =    torch.Size((1, 400)	)
									self.assertEqual(outputs.logits.shape ,      lowercase__	)

									# taken from original model
									_SCREAMING_SNAKE_CASE       =    torch.tensor([-1.05_43, 2.07_64, -0.21_04, 0.44_39, -0.96_58]	).to(lowercase__	)

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









'''simple docstring'''







from __future__ import annotations


def     _UpperCamelCase				(  snake_case__				):
      __A		 =   [0] * len(snake_case__				)
      for i in range(1				,      len(snake_case__				)				):
            __A		 =   duration_times[i - 1] + waiting_times[i - 1]
      return waiting_times


def     _UpperCamelCase				(  snake_case__				,      snake_case__				):
      return [
          duration_time + waiting_times[i]
          for i, duration_time in enumerate(snake_case__				)
      ]


def     _UpperCamelCase				(  snake_case__				):
      return sum(snake_case__				) / len(snake_case__				)


def     _UpperCamelCase				(  snake_case__				):
      return sum(snake_case__				) / len(snake_case__				)


if __name__ == "__main__":
       # process id's
       __A   :							List[str]     	=						[1, 2, 3]

       # ensure that we actually have processes
       if len(processes) == 0:
              print('Zero amount of processes')
              raise SystemExit(0)

       # duration time of all processes
       __A   :							List[Any]     	=						[1_9, 8, 9]

       # ensure we can match each id to a duration time
       if len(duration_times) != len(processes):
              print('Unable to match all id\'s with their duration time')
              raise SystemExit(0)

       # get the waiting times and the turnaround times
       __A   :							Dict     	=						calculate_waiting_times(duration_times)
       __A   :							Optional[int]     	=						calculate_turnaround_times(duration_times, waiting_times)

       # get the average times
       __A   :							Dict     	=						calculate_average_waiting_time(waiting_times)
       __A   :							Tuple     	=						calculate_average_turnaround_time(turnaround_times)

       # print all the results
       print('Process ID\tDuration Time\tWaiting Time\tTurnaround Time')
       for i, process in enumerate(processes):
              print(
                  F"""{process}\t\t{duration_times[i]}\t\t{waiting_times[i]}\t\t"""
                  F"""{turnaround_times[i]}"""
              )
       print(F"""Average waiting time = {average_waiting_time}""")
       print(F"""Average turn around time = {average_turnaround_time}""")


