



"""simple docstring"""




from ..utils import DummyObject, requires_backends


class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Tuple,   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							List[str]	)			->				Union[str, Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Optional[Any]	)			->				Union[str, Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							List[str]	)			->				str:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Union[str, Any],   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							int	)			->				Any:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							int	)			->				Union[str, Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							str	)			->				Any:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Tuple,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							List[Any]	)			->				Union[str, Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[int],   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							List[str]	)			->				Any:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							Dict	)			->				int:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Any,   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							Any	)			->				Optional[int]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							List[Any]	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							str	)			->				Tuple:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							Optional[int]	)			->				Any:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							int	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							int,   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							str	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Tuple,   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							Any	)			->				List[Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Dict	)			->				Tuple:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							Optional[Any]	)			->				int:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							List[Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Any	)			->				List[Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							int	)			->				str:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							str	)			->				str:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							int,   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							str	)			->				Dict:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Union[str, Any]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Union[str, Any]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							int,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Tuple	)			->				str:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							List[Any]	)			->				Dict:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Optional[int]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							List[Any],   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							str	)			->				Optional[int]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Tuple	)			->				List[str]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Tuple	)			->				int:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[int],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							int	)			->				List[Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							List[Any]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							List[Any]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




def      lowercase__   (	*_UpperCAmelCase		,					**_UpperCAmelCase )   ->	Tuple:






      '''simple docstring'''


      requires_backends(UpperCamelCase__		,					['torch'] )


def      lowercase__   (	*_UpperCAmelCase		,					**_UpperCAmelCase )   ->	List[str]:






      '''simple docstring'''


      requires_backends(UpperCamelCase__		,					['torch'] )


def      lowercase__   (	*_UpperCAmelCase		,					**_UpperCAmelCase )   ->	List[str]:






      '''simple docstring'''


      requires_backends(UpperCamelCase__		,					['torch'] )


def      lowercase__   (	*_UpperCAmelCase		,					**_UpperCAmelCase )   ->	Optional[int]:






      '''simple docstring'''


      requires_backends(UpperCamelCase__		,					['torch'] )


def      lowercase__   (	*_UpperCAmelCase		,					**_UpperCAmelCase )   ->	List[Any]:






      '''simple docstring'''


      requires_backends(UpperCamelCase__		,					['torch'] )


def      lowercase__   (	*_UpperCAmelCase		,					**_UpperCAmelCase )   ->	List[str]:






      '''simple docstring'''


      requires_backends(UpperCamelCase__		,					['torch'] )


def      lowercase__   (	*_UpperCAmelCase		,					**_UpperCAmelCase )   ->	int:






      '''simple docstring'''


      requires_backends(UpperCamelCase__		,					['torch'] )


class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							Tuple	)			->				int:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Dict	)			->				Any:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Dict	)			->				int:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Union[str, Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							List[str]	)			->				List[Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							int	)			->				int:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Optional[int],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							int	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Any,   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							Dict	)			->				int:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							Optional[int]	)			->				Any:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							str	)			->				Tuple:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Any,   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							str	)			->				str:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							List[Any]	)			->				int:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Union[str, Any]	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							int,   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							Any	)			->				Tuple:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							int,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Optional[Any]	)			->				Any:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							List[Any]	)			->				Dict:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							List[str],   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							Optional[Any]	)			->				Dict:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Optional[int]	)			->				int:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Any	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Dict,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Dict	)			->				List[Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							int,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							List[Any]	)			->				int:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Any	)			->				Dict:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Dict,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							List[Any]	)			->				Optional[Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[int],   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Optional[Any]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							int	)			->				Union[str, Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							str	)			->				List[str]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							int	)			->				str:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							Any	)			->				Tuple:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							int,   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							Tuple	)			->				List[str]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							Optional[int]	)			->				str:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Union[str, Any]	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[int],   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							int	)			->				str:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							int	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Optional[int]	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							List[str],   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Tuple	)			->				List[str]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							Dict	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							Any	)			->				int:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[int],   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							str	)			->				int:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							List[str]	)			->				str:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							List[Any]	)			->				Any:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							str	)			->				Any:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Any	)			->				Union[str, Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							str	)			->				str:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Dict	)			->				List[str]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							int	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Optional[Any]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							int,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							str	)			->				Tuple:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							str	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Optional[int]	)			->				str:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Dict,   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							Tuple	)			->				Dict:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Optional[Any]	)			->				Tuple:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							Dict	)			->				Any:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							Optional[Any]	)			->				str:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							str	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							Optional[int]	)			->				Tuple:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Any,   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							int	)			->				Optional[int]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							int,   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							str	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Optional[int]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[int],   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							List[Any]	)			->				Dict:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							List[str]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							Optional[int]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Dict,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							Tuple	)			->				Dict:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							List[str]	)			->				int:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Tuple	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[int],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Optional[Any]	)			->				Dict:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							Optional[Any]	)			->				Any:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							Union[str, Any]	)			->				Any:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Tuple,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Optional[int]	)			->				Dict:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							int,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Union[str, Any]	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Dict	)			->				Union[str, Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							List[str],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							Tuple	)			->				List[Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							str	)			->				List[str]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							int,   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Any	)			->				Optional[int]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							int,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Union[str, Any]	)			->				Union[str, Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							Optional[int]	)			->				Union[str, Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							str	)			->				Union[str, Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							List[str],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Any	)			->				int:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							Optional[Any]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Tuple	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Tuple,   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Tuple	)			->				Optional[int]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Union[str, Any],   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							str	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							Optional[Any]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[Any],   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							Optional[Any]	)			->				int:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							int,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							Union[str, Any]	)			->				List[str]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							Union[str, Any]	)			->				Dict:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Union[str, Any],   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							int	)			->				Tuple:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							List[str]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							Dict	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Dict,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							List[str]	)			->				Optional[int]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							int	)			->				Dict:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							Optional[int]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							Optional[Any]	)			->				int:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							str	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							int	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							List[Any]	)			->				int:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							int	)			->				Tuple:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							Optional[int]	)			->				Union[str, Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[int],   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							Optional[int]	)			->				Tuple:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							List[Any],   *lowerCAmelCase					:							Optional[int],   **lowerCAmelCase					:							List[Any]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							str	)			->				int:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[Any],   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Dict	)			->				Tuple:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[int],   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							List[Any]	)			->				Dict:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							str	)			->				Dict:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Union[str, Any],   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							Tuple	)			->				Union[str, Any]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							List[str]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							Optional[int]	)			->				str:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Optional[Any],   *lowerCAmelCase					:							Tuple,   **lowerCAmelCase					:							Union[str, Any]	)			->				int:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Optional[Any],   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							str	)			->				List[str]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							List[str],   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							List[str]	)			->				int:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							Any,   *lowerCAmelCase					:							List[str],   **lowerCAmelCase					:							Tuple	)			->				Dict:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Union[str, Any],   **lowerCAmelCase					:							Dict	)			->				Tuple:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							Union[str, Any]	)			->				Optional[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							List[Any],   **lowerCAmelCase					:							Any	)			->				Any:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							str,   *lowerCAmelCase					:							str,   **lowerCAmelCase					:							int	)			->				int:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Any,   *lowerCAmelCase					:							Any,   **lowerCAmelCase					:							Optional[Any]	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)




class      a__						(  metaclass=UpperCamelCase__   ):
   _lowerCamelCase    							= ['torch']


   def __init__(							self					:							str,   *lowerCAmelCase					:							int,   **lowerCAmelCase					:							List[str]	)			->				List[str]:
         requires_backends(self,   ['torch']	)


   @classmethod
   def 				lowercase (							cls					:							Tuple,   *lowerCAmelCase					:							Dict,   **lowerCAmelCase					:							Any	)			->				List[Any]:
         requires_backends(cls,   ['torch']	)






   @classmethod
   def 				lowercase (							cls					:							Dict,   *lowerCAmelCase					:							Optional[Any],   **lowerCAmelCase					:							List[str]	)			->				Dict:
         requires_backends(cls,   ['torch']	)







import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY




@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class     SCREAMING_SNAKE_CASE__ (						unittest.TestCase      ):
 __SCREAMING_SNAKE_CASE							       =	MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING



 def 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase ):
        A__											=						hf_hub_download(
            repo_id='''nateraw/video-demo''',filename='''archery.mp4''',repo_type='''dataset''' )
        A__											=						VideoClassificationPipeline(model=__lowerCamelCase,image_processor=__lowerCamelCase,top_k=2 )
        A__											=						[
            example_video_filepath,
            '''https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4''',
        ]
        return video_classifier, examples



 def 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase ):
        for example in examples:
               A__											=						video_classifier(__lowerCamelCase )

               self.assertEqual(
                   __lowerCamelCase,[
                       {'''score''': ANY(__lowerCamelCase ), '''label''': ANY(__lowerCamelCase )},
                       {'''score''': ANY(__lowerCamelCase ), '''label''': ANY(__lowerCamelCase )},
                   ],)



 @require_torch
 def 				UpperCamelCase			(							self ):
        A__											=						'''hf-internal-testing/tiny-random-VideoMAEForVideoClassification'''
        A__											=						VideoMAEFeatureExtractor(
            size={'''shortest_edge''': 10},crop_size={'''height''': 10, '''width''': 10} )
        A__											=						pipeline(
            '''video-classification''',model=__lowerCamelCase,feature_extractor=__lowerCamelCase,frame_sampling_rate=4 )

        A__											=						hf_hub_download(repo_id='''nateraw/video-demo''',filename='''archery.mp4''',repo_type='''dataset''' )
        A__											=						video_classifier(__lowerCamelCase,top_k=2 )
        self.assertEqual(
            nested_simplify(__lowerCamelCase,decimals=4 ),[{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],)

        A__											=						video_classifier(
            [
                video_file_path,
                video_file_path,
            ],top_k=2,)
        self.assertEqual(
            nested_simplify(__lowerCamelCase,decimals=4 ),[
                [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],
                [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],
            ],)




 @require_tf
 def 				UpperCamelCase			(							self ):
        pass





