





from __future__ import annotations

from typing import Any






class        _a:







		def __init__(    self ,						__snake_case = 6				)      ->      None:


							'''simple docstring'''

							_snake_case       :					Node | None				       =   None
							_snake_case       :					Node | None				       =   None
							self.create_linked_list(__snake_case				)







		def        lowercase       (    self ,						__snake_case				)      ->      None:


							'''simple docstring'''

							_snake_case       :					Dict				       =   Node()
							_snake_case       :					Union[str, Any]				       =   current_node
							_snake_case       :					Any				       =   current_node
							_snake_case       :					Union[str, Any]				       =   current_node
							for _ in range(1 ,						__snake_case				):
												_snake_case       :					int				       =   Node()
												_snake_case       :					List[str]				       =   current_node
												_snake_case       :					Dict				       =   previous_node
												_snake_case       :					Optional[int]				       =   current_node
							_snake_case       :					int				       =   self.front
							_snake_case       :					Any				       =   previous_node







		def        lowercase       (    self				)      ->      bool:


							'''simple docstring'''

							return (
							    self.front == self.rear
							    and self.front is not None
							    and self.front.data is None
							)







		def        lowercase       (    self				)      ->      Any | None:


							'''simple docstring'''

							self.check_can_perform_operation()
							return self.front.data if self.front else None







		def        lowercase       (    self ,						__snake_case				)      ->      None:


							'''simple docstring'''

							if self.rear is None:
												return

							self.check_is_full()
							if not self.is_empty():
												_snake_case       :					Any				       =   self.rear.next
							if self.rear:
												_snake_case       :					Optional[Any]				       =   data







		def        lowercase       (    self				)      ->      Any:


							'''simple docstring'''

							self.check_can_perform_operation()
							if self.rear is None or self.front is None:
												return None
							if self.front == self.rear:
												_snake_case       :					int				       =   self.front.data
												_snake_case       :					str				       =   None
												return data

							_snake_case       :					Union[str, Any]				       =   self.front
							_snake_case       :					List[str]				       =   old_front.next
							_snake_case       :					Tuple				       =   old_front.data
							_snake_case       :					str				       =   None
							return data







		def        lowercase       (    self				)      ->      None:


							'''simple docstring'''

							if self.is_empty():
												raise Exception("Empty Queue"				)







		def        lowercase       (    self				)      ->      None:


							'''simple docstring'''

							if self.rear and self.rear.next == self.front:
												raise Exception("Full Queue"				)






class        _a:







		def __init__(    self				)      ->      None:


							'''simple docstring'''

							_snake_case       :					Any | None				       =   None
							_snake_case       :					Node | None				       =   None
							_snake_case       :					Node | None				       =   None


if __name__ == "__main__":
							import doctest

							doctest.testmod()






from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCAmelCase :Tuple     =    logging.get_logger(__name__)

__lowerCAmelCase :int     =    {
    'facebook/timesformer': 'https://huggingface.co/facebook/timesformer/resolve/main/config.json',
}






class        _a(    __A    ):
		lowerCamelCase__     :Optional[Any]   				=		'timesformer'







		def __init__(    self ,						__snake_case=2_2_4 ,						__snake_case=1_6 ,						__snake_case=3 ,						__snake_case=8 ,						__snake_case=7_6_8 ,						__snake_case=1_2 ,						__snake_case=1_2 ,						__snake_case=3_0_7_2 ,						__snake_case="gelu" ,						__snake_case=0.0 ,						__snake_case=0.0 ,						__snake_case=0.02 ,						__snake_case=1E-6 ,						__snake_case=True ,						__snake_case="divided_space_time" ,						__snake_case=0 ,						**__snake_case ,						)      ->      str:


							'''simple docstring'''

							super().__init__(**__snake_case				)

							_snake_case       :					Optional[Any]				       =   image_size
							_snake_case       :					Optional[int]				       =   patch_size
							_snake_case       :					str				       =   num_channels
							_snake_case       :					Tuple				       =   num_frames

							_snake_case       :					Union[str, Any]				       =   hidden_size
							_snake_case       :					Optional[int]				       =   num_hidden_layers
							_snake_case       :					List[Any]				       =   num_attention_heads
							_snake_case       :					Optional[int]				       =   intermediate_size
							_snake_case       :					List[str]				       =   hidden_act
							_snake_case       :					Optional[int]				       =   hidden_dropout_prob
							_snake_case       :					Optional[Any]				       =   attention_probs_dropout_prob
							_snake_case       :					Dict				       =   initializer_range
							_snake_case       :					Optional[int]				       =   layer_norm_eps
							_snake_case       :					str				       =   qkv_bias

							_snake_case       :					List[str]				       =   attention_type
							_snake_case       :					Optional[int]				       =   drop_path_rate