
'''simple docstring'''





from __future__ import annotations

from typing import Any

class 						a   :




				def __init__(							self	:				Union[str, Any],    SCREAMING_SNAKE_CASE_	:				int = 6      ):
										snake_case       :     Node | None =    None
										snake_case       :     Node | None =    None
										self.create_linked_list(SCREAMING_SNAKE_CASE_      )




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




				def 	__snake_case							(							self	:				Optional[int]      ):
										return (
										    self.front == self.rear
										    and self.front is not None
										    and self.front.data is None
										)




				def 	__snake_case							(							self	:				Tuple      ):
										self.check_can_perform_operation()
										return self.front.data if self.front else None




				def 	__snake_case							(							self	:				Any,    SCREAMING_SNAKE_CASE_	:				Any      ):
										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       :     Dict =    data




				def 	__snake_case							(							self	:				int      ):
										self.check_can_perform_operation()
										if self.rear is None or self.front is None:
																return None
										if self.front == self.rear:
																snake_case       :     Union[str, Any] =    self.front.data
																snake_case       :     str =    None
																return data

										snake_case       :     List[Any] =    self.front
										snake_case       :     List[str] =    old_front.next
										snake_case       :     Dict =    old_front.data
										snake_case       :     Optional[Any] =    None
										return data




				def 	__snake_case							(							self	:				Dict      ):
										if self.is_empty():
																raise Exception('''Empty Queue'''      )




				def 	__snake_case							(							self	:				Optional[Any]      ):
										if self.rear and self.rear.next == self.front:
																raise Exception('''Full Queue'''      )




class 						a   :




				def __init__(							self	:				int      ):
										snake_case       :     Any | None =    None
										snake_case       :     Node | None =    None
										snake_case       :     Node | None =    None


if __name__ == "__main__":
						import doctest

						doctest.testmod()



'''simple docstring'''





import os
import sys

UpperCAmelCase    					=   os.path.join(os.path.dirname(__file__), "src")
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


UpperCAmelCase    					=   [
    "torch",
    "numpy",
    "tokenizers",
    "filelock",
    "requests",
    "tqdm",
    "regex",
    "sentencepiece",
    "sacremoses",
    "importlib_metadata",
    "huggingface_hub",
]

@add_start_docstrings(AutoConfig.__doc__       )
def      A (       *A_							:					Optional[Any]    ,							**A_							:					List[str]       ):
						return AutoConfig.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoTokenizer.__doc__       )
def      A (       *A_							:					Dict    ,							**A_							:					str       ):
						return AutoTokenizer.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoModel.__doc__       )
def      A (       *A_							:					Union[str, Any]    ,							**A_							:					Optional[Any]       ):
						return AutoModel.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoModelForCausalLM.__doc__       )
def      A (       *A_							:					str    ,							**A_							:					Optional[Any]       ):
						return AutoModelForCausalLM.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoModelForMaskedLM.__doc__       )
def      A (       *A_							:					List[str]    ,							**A_							:					Optional[Any]       ):
						return AutoModelForMaskedLM.from_pretrained(*A_    ,							**A_       )

@add_start_docstrings(AutoModelForSequenceClassification.__doc__       )
def      A (       *A_							:					Tuple    ,							**A_							:					List[str]       ):
						return AutoModelForSequenceClassification.from_pretrained(*A_    ,							**A_       )





@add_start_docstrings(AutoModelForQuestionAnswering.__doc__       )
def      A (       *A_							:					Tuple    ,							**A_							:					Any       ):
						return AutoModelForQuestionAnswering.from_pretrained(*A_    ,							**A_       )

