

from ..utils import DummyObject, requires_backends







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[str]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[str]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )





def 			UpperCAmelCase__				(			*_A      : Optional[Any]	,      **_A      : Optional[Any]							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : Union[str, Any]	,      **_A      : List[Any]							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : Union[str, Any]	,      **_A      : Tuple							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : List[str]	,      **_A      : List[str]							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : Dict	,      **_A      : Dict							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : List[str]	,      **_A      : str							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)




def 			UpperCAmelCase__				(			*_A      : Optional[int]	,      **_A      : Dict							):





  '''simple docstring'''







  requires_backends(_A	,      ['''torch''']							)







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Tuple    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Tuple    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[str]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Any    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[str]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Tuple    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    List[str]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	List[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Dict    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Any    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Dict:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Union[str, Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Any:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[int]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	Union[str, Any]    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Optional[int]:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    List[Any]:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )







class 						__magic_name__			(							metaclass=lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	int    =   ['torch']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(self,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    Tuple:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



   @classmethod
   def  _UpperCAmelCase (				cls,    *lowercase_,    **lowercase_       )							->    str:






     """simple docstring"""






     requires_backends(cls,    ['''torch''']       )



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase           =					{'''configuration_xlnet''': ['''XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XLNetConfig''']}

try:
       if not is_sentencepiece_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					['''XLNetTokenizer''']

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					['''XLNetTokenizerFast''']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					[
           '''XLNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''XLNetForMultipleChoice''',
           '''XLNetForQuestionAnswering''',
           '''XLNetForQuestionAnsweringSimple''',
           '''XLNetForSequenceClassification''',
           '''XLNetForTokenClassification''',
           '''XLNetLMHeadModel''',
           '''XLNetModel''',
           '''XLNetPreTrainedModel''',
           '''load_tf_weights_in_xlnet''',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					[
           '''TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''TFXLNetForMultipleChoice''',
           '''TFXLNetForQuestionAnsweringSimple''',
           '''TFXLNetForSequenceClassification''',
           '''TFXLNetForTokenClassification''',
           '''TFXLNetLMHeadModel''',
           '''TFXLNetMainLayer''',
           '''TFXLNetModel''',
           '''TFXLNetPreTrainedModel''',
       ]


if TYPE_CHECKING:
       from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

       try:
              if not is_sentencepiece_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_xlnet import XLNetTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_xlnet_fast import XLNetTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_xlnet import (
                  XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
                  XLNetForMultipleChoice,
                  XLNetForQuestionAnswering,
                  XLNetForQuestionAnsweringSimple,
                  XLNetForSequenceClassification,
                  XLNetForTokenClassification,
                  XLNetLMHeadModel,
                  XLNetModel,
                  XLNetPreTrainedModel,
                  load_tf_weights_in_xlnet,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_xlnet import (
                  TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFXLNetForMultipleChoice,
                  TFXLNetForQuestionAnsweringSimple,
                  TFXLNetForSequenceClassification,
                  TFXLNetForTokenClassification,
                  TFXLNetLMHeadModel,
                  TFXLNetMainLayer,
                  TFXLNetModel,
                  TFXLNetPreTrainedModel,
              )

else:
       import sys

       lowerCamelCase           =					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
