






from ..utils import DummyObject, requires_backends




class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Tuple:
								requires_backends(cls       ,			['torch']					)






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






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[Any]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




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






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[str]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






def 						__UpperCAmelCase			(     *a_							,     **a_):
							requires_backends(a_							,     ['torch'])





def 						__UpperCAmelCase			(     *a_							,     **a_):
							requires_backends(a_							,     ['torch'])





def 						__UpperCAmelCase			(     *a_							,     **a_):
							requires_backends(a_							,     ['torch'])





def 						__UpperCAmelCase			(     *a_							,     **a_):
							requires_backends(a_							,     ['torch'])





def 						__UpperCAmelCase			(     *a_							,     **a_):
							requires_backends(a_							,     ['torch'])





def 						__UpperCAmelCase			(     *a_							,     **a_):
							requires_backends(a_							,     ['torch'])





def 						__UpperCAmelCase			(     *a_							,     **a_):
							requires_backends(a_							,     ['torch'])




class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[Any]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[Any]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[Any]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[str]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Tuple:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[Any]:
								requires_backends(cls       ,			['torch']					)






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






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[str]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






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






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[Any]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Tuple:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




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






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[Any]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Tuple:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




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






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Tuple:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






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






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[Any]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[str]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Any:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




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






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Tuple:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[int]:
								requires_backends(cls       ,			['torch']					)






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






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Optional[Any]:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    Dict:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    str:
								requires_backends(cls       ,			['torch']					)






class  UpperCamelCase_      (			metaclass=snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= ['''torch''']




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




	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    int:
								requires_backends(cls       ,			['torch']					)






	@classmethod
	def 							_UpperCamelCase			(       cls       ,			*a       ,			**a					)       ->    List[str]:
								requires_backends(cls       ,			['torch']					)













import warnings

from ...utils import logging
from .image_processing_perceiver import PerceiverImageProcessor


lowercase  							=					logging.get_logger(__name__)




class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			*a       ,			**a					)       ->    None:
								warnings.warn(
								    'The class PerceiverFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
								    ' Please use PerceiverImageProcessor instead.'       ,			a       ,			)
								super().__init__(*a       ,			**a					)





