


'''simple docstring'''


from ..utils import DummyObject, requires_backends






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	str          =     ['torch']




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



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Optional[int] )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     str )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Any          =     ['torch']




			def __init__(		self  :     List[str]	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     List[str] )   ->Dict:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Union[str, Any] )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     List[str] )   ->List[str]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Dict          =     ['torch']




			def __init__(		self  :     Optional[Any]	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     int )   ->int:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     int )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Optional[int] )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[Any]          =     ['torch']




			def __init__(		self  :     Optional[Any]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Dict )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     int )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     int )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	int          =     ['torch']




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



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     List[Any] )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Any )   ->List[str]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	str          =     ['torch']




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



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Optional[int] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[int]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     str )   ->int:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[Any]          =     ['torch']




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



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Optional[Any] )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     Optional[int] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	int          =     ['torch']




			def __init__(		self  :     Optional[int]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Union[str, Any] )   ->Dict:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     Any )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     Tuple )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[int]          =     ['torch']




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



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     str )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     Union[str, Any] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Tuple          =     ['torch']




			def __init__(		self  :     Optional[int]	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Optional[int] )   ->Dict:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Any )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     int )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Dict          =     ['torch']




			def __init__(		self  :     str	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     Any )   ->int:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     List[str] )   ->List[str]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     List[str] )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






def  __lowerCAmelCase (*__lowerCAmelCase      , **__lowerCAmelCase   ):
		requires_backends(_lowerCAmelCase      , ["torch"]   )






def  __lowerCAmelCase (*__lowerCAmelCase      , **__lowerCAmelCase   ):
		requires_backends(_lowerCAmelCase      , ["torch"]   )






def  __lowerCAmelCase (*__lowerCAmelCase      , **__lowerCAmelCase   ):
		requires_backends(_lowerCAmelCase      , ["torch"]   )






def  __lowerCAmelCase (*__lowerCAmelCase      , **__lowerCAmelCase   ):
		requires_backends(_lowerCAmelCase      , ["torch"]   )






def  __lowerCAmelCase (*__lowerCAmelCase      , **__lowerCAmelCase   ):
		requires_backends(_lowerCAmelCase      , ["torch"]   )






def  __lowerCAmelCase (*__lowerCAmelCase      , **__lowerCAmelCase   ):
		requires_backends(_lowerCAmelCase      , ["torch"]   )






def  __lowerCAmelCase (*__lowerCAmelCase      , **__lowerCAmelCase   ):
		requires_backends(_lowerCAmelCase      , ["torch"]   )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	int          =     ['torch']




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



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     int )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     List[Any] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Tuple          =     ['torch']




			def __init__(		self  :     Union[str, Any]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     int )   ->Any:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     List[str] )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     str )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	str          =     ['torch']




			def __init__(		self  :     Tuple	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     str )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     int )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     Any )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Any          =     ['torch']




			def __init__(		self  :     List[str]	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Tuple )   ->Any:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Tuple )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     List[str] )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Union[str, Any]          =     ['torch']




			def __init__(		self  :     Optional[Any]	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Tuple )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     str )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     Tuple )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[int]          =     ['torch']




			def __init__(		self  :     str	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     int )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     Any )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     int )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	int          =     ['torch']




			def __init__(		self  :     List[Any]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     Tuple )   ->Any:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     Tuple )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Tuple )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[int]          =     ['torch']




			def __init__(		self  :     str	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     List[Any] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Any )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     List[str] )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	str          =     ['torch']




			def __init__(		self  :     int	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Optional[Any] )   ->str:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     List[Any] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Any )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Tuple          =     ['torch']




			def __init__(		self  :     Dict	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     Optional[Any] )   ->List[Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Optional[Any] )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[int]	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Dict )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Dict          =     ['torch']




			def __init__(		self  :     int	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Dict )   ->Tuple:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Tuple )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     Any )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Dict          =     ['torch']




			def __init__(		self  :     Optional[int]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Any )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     int )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Tuple )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	str          =     ['torch']




			def __init__(		self  :     Union[str, Any]	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Tuple )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     str )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     List[Any] )   ->List[str]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[Any]          =     ['torch']




			def __init__(		self  :     Any	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     List[str] )   ->int:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Tuple )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     List[Any] )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	str          =     ['torch']




			def __init__(		self  :     Union[str, Any]	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Any )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     Tuple )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Optional[int] )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Tuple          =     ['torch']




			def __init__(		self  :     List[Any]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     List[str] )   ->Tuple:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     Any )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     Union[str, Any] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Tuple          =     ['torch']




			def __init__(		self  :     str	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     Union[str, Any] )   ->Dict:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Optional[Any] )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     Optional[int] )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Any          =     ['torch']




			def __init__(		self  :     Optional[Any]	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Dict )   ->str:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Dict )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     List[Any] )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Tuple          =     ['torch']




			def __init__(		self  :     Tuple	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Optional[Any] )   ->str:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     List[str] )   ->List[str]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     str )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Any          =     ['torch']




			def __init__(		self  :     List[str]	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Any )   ->Tuple:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Optional[Any] )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Dict )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	int          =     ['torch']




			def __init__(		self  :     Optional[Any]	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     List[Any] )   ->Dict:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     str )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     str )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[int]          =     ['torch']




			def __init__(		self  :     List[Any]	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     str )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Union[str, Any]	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     Union[str, Any] )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Union[str, Any]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     int )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	str          =     ['torch']




			def __init__(		self  :     Any	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     str )   ->int:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Tuple )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Union[str, Any]	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Tuple )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[Any]          =     ['torch']




			def __init__(		self  :     Any	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Union[str, Any] )   ->List[Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     int )   ->List[str]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     Tuple	,  **lowerCamelCase__  :     Tuple )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	List[Any]          =     ['torch']




			def __init__(		self  :     Optional[int]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Optional[int] )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Optional[int] )   ->List[str]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     str )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	List[Any]          =     ['torch']




			def __init__(		self  :     Tuple	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Optional[int] )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     int )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[int]	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Optional[int] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	int          =     ['torch']




			def __init__(		self  :     Any	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     Optional[Any] )   ->int:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Optional[Any] )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Tuple )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Dict          =     ['torch']




			def __init__(		self  :     List[Any]	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     Tuple )   ->List[str]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     List[Any] )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     Any	,  **lowerCamelCase__  :     Dict )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Dict          =     ['torch']




			def __init__(		self  :     List[Any]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     Optional[Any] )   ->List[str]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Optional[Any] )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Dict )   ->int:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	List[Any]          =     ['torch']




			def __init__(		self  :     Union[str, Any]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     List[Any] )   ->int:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Union[str, Any]	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     Tuple )   ->int:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     List[Any] )   ->List[str]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Union[str, Any]          =     ['torch']




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



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     List[str] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     str	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Tuple )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Union[str, Any]          =     ['torch']




			def __init__(		self  :     List[Any]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     int )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     List[str] )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[int]	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Union[str, Any] )   ->int:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	List[Any]          =     ['torch']




			def __init__(		self  :     str	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Optional[int] )   ->Any:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Dict )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[int]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     int )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Dict          =     ['torch']




			def __init__(		self  :     List[str]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     int )   ->Tuple:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[Any]	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Dict )   ->Any:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     Optional[Any] )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	str          =     ['torch']




			def __init__(		self  :     List[Any]	,  *lowerCamelCase__  :     Dict	,  **lowerCamelCase__  :     Optional[int] )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Dict	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     Any )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     List[Any]	,  **lowerCamelCase__  :     Union[str, Any] )   ->int:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Union[str, Any]          =     ['torch']




			def __init__(		self  :     Optional[Any]	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Tuple )   ->Dict:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Any	,  *lowerCamelCase__  :     int	,  **lowerCamelCase__  :     Any )   ->Optional[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[str]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     List[Any] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Tuple          =     ['torch']




			def __init__(		self  :     int	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     List[str] )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     List[str] )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Optional[int]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     int )   ->Dict:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	Optional[Any]          =     ['torch']




			def __init__(		self  :     Optional[int]	,  *lowerCamelCase__  :     str	,  **lowerCamelCase__  :     Any )   ->Dict:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     int	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Tuple )   ->Optional[int]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Tuple	,  *lowerCamelCase__  :     Optional[int]	,  **lowerCamelCase__  :     Union[str, Any] )   ->List[Any]:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






class 	lowerCAmelCase__			(			metaclass=__snake_case	):
			lowerCAmelCase :	List[Any]          =     ['torch']




			def __init__(		self  :     int	,  *lowerCamelCase__  :     Optional[Any]	,  **lowerCamelCase__  :     Optional[int] )   ->Union[str, Any]:



					'''simple docstring'''







					requires_backends(self	,  ["torch"] )




			@classmethod
			def 							lowerCAmelCase__    (		cls  :     List[Any]	,  *lowerCamelCase__  :     Union[str, Any]	,  **lowerCamelCase__  :     Any )   ->str:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )






			@classmethod
			def 							lowerCAmelCase__    (		cls  :     Union[str, Any]	,  *lowerCamelCase__  :     List[str]	,  **lowerCamelCase__  :     List[Any] )   ->Tuple:



					'''simple docstring'''







					requires_backends(cls	,  ["torch"] )









'''simple docstring'''


# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import sys
import warnings
from os.path import abspath, dirname, join


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
lowerCamelCase__    	=     abspath(join(dirname(dirname(dirname(__file__))), 'src'))
sys.path.insert(1, git_repo_path)


# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='ignore', category=FutureWarning)






def  __lowerCAmelCase (__lowerCAmelCase   ):
		from transformers.testing_utils import pytest_addoption_shared

		pytest_addoption_shared(__lowerCAmelCase   )






def  __lowerCAmelCase (__lowerCAmelCase   ):
		from transformers.testing_utils import pytest_terminal_summary_main

		_UpperCAmelCase		:       Optional[int]								=      terminalreporter.config.getoption("--make-reports"   )
		if make_reports:
				pytest_terminal_summary_main(__lowerCAmelCase      , id=__lowerCAmelCase   )



