




from __future__ import annotations

from collections.abc import Iterator
from typing import Any






class    __lowerCAmelCase			:







			def __init__(	self   :      List[str]   ,   snake_case__   :      Any				):




									"""simple docstring"""


									_UpperCAmelCase													=					data
									_UpperCAmelCase													=					None







			def __str__(	self   :      Dict				):




									"""simple docstring"""


									return F"""{self.data}"""






class    __lowerCAmelCase			:







			def __init__(	self   :      Optional[int]				):




									"""simple docstring"""


									_UpperCAmelCase													=					None
									_UpperCAmelCase													=					None







			def __iter__(	self   :      str				):




									"""simple docstring"""


									_UpperCAmelCase													=					self.front
									while node:
															yield node.data
															_UpperCAmelCase													=					node.next







			def __len__(	self   :      int				):




									"""simple docstring"""


									return len(tuple(iter(self				)				)				)







			def __str__(	self   :      Optional[Any]				):




									"""simple docstring"""


									return " <- ".join(str(snake_case__				) for item in self				)







			def UpperCamelCase      (	self   :      List[str]				):




									"""simple docstring"""


									return len(self				) == 0







			def UpperCamelCase      (	self   :      str   ,   snake_case__   :      Any				):




									"""simple docstring"""


									_UpperCAmelCase													=					Node(snake_case__				)
									if self.is_empty():
															_UpperCAmelCase													=					_UpperCAmelCase													=					node
									else:
															assert isinstance(self.rear   ,   snake_case__				)
															_UpperCAmelCase													=					node
															_UpperCAmelCase													=					node







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




									"""simple docstring"""


									if self.is_empty():
															raise IndexError("dequeue from empty queue"				)
									assert isinstance(self.front   ,   snake_case__				)
									_UpperCAmelCase													=					self.front
									_UpperCAmelCase													=					self.front.next
									if self.front is None:
															_UpperCAmelCase													=					None
									return node.data







			def UpperCamelCase      (	self   :      List[str]				):




									"""simple docstring"""


									_UpperCAmelCase													=					_UpperCAmelCase													=					None


if __name__ == "__main__":
				from doctest import testmod

				testmod()










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


lowercase_     :    int      =			{
    'configuration_videomae': ['VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VideoMAEConfig'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_     :    List[str]      =			[
				    'VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'VideoMAEForPreTraining',
				    'VideoMAEModel',
				    'VideoMAEPreTrainedModel',
				    'VideoMAEForVideoClassification',
				]

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_     :    Any      =			['VideoMAEFeatureExtractor']
				lowercase_     :    Dict      =			['VideoMAEImageProcessor']

if TYPE_CHECKING:
				from .configuration_videomae import VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP, VideoMAEConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_videomae import (
								    VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST,
								    VideoMAEForPreTraining,
								    VideoMAEForVideoClassification,
								    VideoMAEModel,
								    VideoMAEPreTrainedModel,
								)

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_videomae import VideoMAEFeatureExtractor
								from .image_processing_videomae import VideoMAEImageProcessor

else:
				import sys

				lowercase_     :    int      =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




