





from ..utils import DummyObject, requires_backends





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Dict	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Any	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Any:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    int	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Tuple	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    str	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    str	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[int]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])



def A_     (		*A__		,				**A__    )  ->		int:
       requires_backends(A__		,				['torch']    )



def A_     (		*A__		,				**A__    )  ->		List[Any]:
       requires_backends(A__		,				['torch']    )



def A_     (		*A__		,				**A__    )  ->		Union[str, Any]:
       requires_backends(A__		,				['torch']    )



def A_     (		*A__		,				**A__    )  ->		Optional[int]:
       requires_backends(A__		,				['torch']    )



def A_     (		*A__		,				**A__    )  ->		Tuple:
       requires_backends(A__		,				['torch']    )



def A_     (		*A__		,				**A__    )  ->		str:
       requires_backends(A__		,				['torch']    )



def A_     (		*A__		,				**A__    )  ->		List[Any]:
       requires_backends(A__		,				['torch']    )





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    int	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Any:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Tuple	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    int	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[int]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Tuple	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Any:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    str	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[int]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Any	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    int	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Dict	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    int	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Tuple	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[int]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    int	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Tuple	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    str	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Tuple	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[int]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Any	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Tuple	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						int:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    str	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[int]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Dict	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						str:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    int	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Any	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Any:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[int]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    Dict	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

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







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						List[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



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

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Tuple:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])





class 			A__   (							metaclass=__UpperCAmelCase     ):




   """simple docstring"""



   __A       :    str	  =  ['''torch''']

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







          '''simple docstring'''

          requires_backends(self ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Dict:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])

   @classmethod
   def 							__lowercase		( cls ,  *lowercase ,  **lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          requires_backends(cls ,  ['torch'])









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


lowercase				:	str      						=  {
    """configuration_vision_encoder_decoder""": ["""VisionEncoderDecoderConfig""", """VisionEncoderDecoderOnnxConfig"""]
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	Optional[Any]      						=  ["""VisionEncoderDecoderModel"""]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	Optional[int]      						=  ["""TFVisionEncoderDecoderModel"""]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	List[str]      						=  ["""FlaxVisionEncoderDecoderModel"""]

if TYPE_CHECKING:
    from .configuration_vision_encoder_decoder import VisionEncoderDecoderConfig, VisionEncoderDecoderOnnxConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_vision_encoder_decoder import VisionEncoderDecoderModel

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_vision_encoder_decoder import TFVisionEncoderDecoderModel

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_vision_encoder_decoder import FlaxVisionEncoderDecoderModel

else:
    import sys

    lowercase				:	Optional[int]      						=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


