


from ..utils import DummyObject, requires_backends
class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							Union[str, Any]	   =       ['flax']

     def __init__(					self:str     ,		*_a:Tuple     ,		**_a:str   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:str     ,		*_a:Optional[int]     ,		**_a:Optional[Any]   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:str     ,		*_a:Union[str, Any]     ,		**_a:List[str]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							List[Any]	   =       ['flax']

     def __init__(					self:Dict     ,		*_a:int     ,		**_a:List[str]   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:List[Any]     ,		*_a:List[str]     ,		**_a:List[Any]   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Any     ,		*_a:Tuple     ,		**_a:List[str]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							Optional[int]	   =       ['flax']

     def __init__(					self:List[Any]     ,		*_a:Any     ,		**_a:int   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Any     ,		*_a:List[str]     ,		**_a:Tuple   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:int     ,		*_a:str     ,		**_a:int   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							Optional[Any]	   =       ['flax']

     def __init__(					self:Tuple     ,		*_a:List[Any]     ,		**_a:Tuple   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Union[str, Any]     ,		*_a:Any     ,		**_a:int   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:List[Any]     ,		*_a:Optional[int]     ,		**_a:List[str]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							Optional[Any]	   =       ['flax']

     def __init__(					self:List[str]     ,		*_a:Any     ,		**_a:int   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Any     ,		*_a:Optional[Any]     ,		**_a:Optional[int]   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Optional[int]     ,		*_a:Any     ,		**_a:Tuple   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							List[Any]	   =       ['flax']

     def __init__(					self:Optional[Any]     ,		*_a:int     ,		**_a:List[str]   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Union[str, Any]     ,		*_a:Tuple     ,		**_a:Any   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:List[Any]     ,		*_a:Any     ,		**_a:Any   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							Optional[Any]	   =       ['flax']

     def __init__(					self:Any     ,		*_a:Any     ,		**_a:Tuple   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:int     ,		*_a:Dict     ,		**_a:Union[str, Any]   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:int     ,		*_a:int     ,		**_a:List[str]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							Optional[Any]	   =       ['flax']

     def __init__(					self:Any     ,		*_a:Optional[int]     ,		**_a:Any   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Optional[Any]     ,		*_a:List[Any]     ,		**_a:Tuple   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:List[str]     ,		*_a:Any     ,		**_a:List[Any]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							str	   =       ['flax']

     def __init__(					self:Optional[Any]     ,		*_a:Any     ,		**_a:List[Any]   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Any     ,		*_a:List[Any]     ,		**_a:List[str]   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:str     ,		*_a:Dict     ,		**_a:List[str]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							List[str]	   =       ['flax']

     def __init__(					self:int     ,		*_a:Union[str, Any]     ,		**_a:Tuple   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:List[Any]     ,		*_a:Optional[int]     ,		**_a:int   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Union[str, Any]     ,		*_a:List[str]     ,		**_a:Optional[Any]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							List[str]	   =       ['flax']

     def __init__(					self:str     ,		*_a:List[str]     ,		**_a:List[Any]   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:List[Any]     ,		*_a:int     ,		**_a:Union[str, Any]   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Tuple     ,		*_a:Optional[int]     ,		**_a:List[str]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							Tuple	   =       ['flax']

     def __init__(					self:Optional[Any]     ,		*_a:Optional[int]     ,		**_a:Optional[Any]   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Any     ,		*_a:Any     ,		**_a:Any   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Any     ,		*_a:Optional[Any]     ,		**_a:Union[str, Any]   ):
       requires_backends(cls     ,		['''flax''']   )




class 		__magic_name__						(metaclass=snake_case_				):





     '''simple docstring'''



     __lowercase				:							List[Any]	   =       ['flax']

     def __init__(					self:Optional[Any]     ,		*_a:Optional[Any]     ,		**_a:Any   ):
       requires_backends(self     ,		['''flax''']   )

     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:List[Any]     ,		*_a:Union[str, Any]     ,		**_a:Dict   ):
       requires_backends(cls     ,		['''flax''']   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					cls:Optional[int]     ,		*_a:Any     ,		**_a:str   ):
       requires_backends(cls     ,		['''flax''']   )





import os
import sys

lowerCamelCase__							:						Optional[int]							     =   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,
)


lowerCamelCase__							:						Optional[int]							     =   [
    """torch""",
    """numpy""",
    """tokenizers""",
    """filelock""",
    """requests""",
    """tqdm""",
    """regex""",
    """sentencepiece""",
    """sacremoses""",
    """importlib_metadata""",
    """huggingface_hub""",
]







@add_start_docstrings(AutoConfig.__doc__				)
def SCREAMING_SNAKE_CASE	(			*__lowerCAmelCase							,   **__lowerCAmelCase				)    ->				Any:
  return AutoConfig.from_pretrained(*__lowerCAmelCase							,   **__lowerCAmelCase				)







@add_start_docstrings(AutoTokenizer.__doc__				)
def SCREAMING_SNAKE_CASE	(			*__lowerCAmelCase							,   **__lowerCAmelCase				)    ->				List[str]:
  return AutoTokenizer.from_pretrained(*__lowerCAmelCase							,   **__lowerCAmelCase				)







@add_start_docstrings(AutoModel.__doc__				)
def SCREAMING_SNAKE_CASE	(			*__lowerCAmelCase							,   **__lowerCAmelCase				)    ->				Tuple:
  return AutoModel.from_pretrained(*__lowerCAmelCase							,   **__lowerCAmelCase				)







@add_start_docstrings(AutoModelForCausalLM.__doc__				)
def SCREAMING_SNAKE_CASE	(			*__lowerCAmelCase							,   **__lowerCAmelCase				)    ->				Union[str, Any]:
  return AutoModelForCausalLM.from_pretrained(*__lowerCAmelCase							,   **__lowerCAmelCase				)







@add_start_docstrings(AutoModelForMaskedLM.__doc__				)
def SCREAMING_SNAKE_CASE	(			*__lowerCAmelCase							,   **__lowerCAmelCase				)    ->				List[Any]:
  return AutoModelForMaskedLM.from_pretrained(*__lowerCAmelCase							,   **__lowerCAmelCase				)







@add_start_docstrings(AutoModelForSequenceClassification.__doc__				)
def SCREAMING_SNAKE_CASE	(			*__lowerCAmelCase							,   **__lowerCAmelCase				)    ->				List[str]:
  return AutoModelForSequenceClassification.from_pretrained(*__lowerCAmelCase							,   **__lowerCAmelCase				)







@add_start_docstrings(AutoModelForQuestionAnswering.__doc__				)
def SCREAMING_SNAKE_CASE	(			*__lowerCAmelCase							,   **__lowerCAmelCase				)    ->				Union[str, Any]:
  return AutoModelForQuestionAnswering.from_pretrained(*__lowerCAmelCase							,   **__lowerCAmelCase				)

