





'''simple docstring'''







from ..utils import DummyObject, requires_backends
class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					str					,				*__a     :					Optional[int]					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Optional[Any]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Union[str, Any]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					int					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					int					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					Optional[int]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					Optional[int]					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Tuple					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Dict					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Optional[Any]					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Tuple					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					str					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					int					,				*__a     :					Dict					,				**__a     :					Tuple					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					str					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					str					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					List[Any]					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Union[str, Any]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					List[str]					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					List[Any]					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					int					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Optional[Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					int					,				*__a     :					int					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Any					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Union[str, Any]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					str					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Any					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					int					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					Dict					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Optional[int]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Union[str, Any]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					Any					,				**__a     :					Dict					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Tuple					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					List[str]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)






def  _lowerCamelCase				( *lowercase						:      Dict    ,							**lowercase						:      Optional[Any]						)	->	List[Any]:
				requires_backends(a_    ,							["torch"]						)






def  _lowerCamelCase				( *lowercase						:      List[Any]    ,							**lowercase						:      Optional[Any]						)	->	List[Any]:
				requires_backends(a_    ,							["torch"]						)






def  _lowerCamelCase				( *lowercase						:      Optional[Any]    ,							**lowercase						:      Dict						)	->	List[str]:
				requires_backends(a_    ,							["torch"]						)






def  _lowerCamelCase				( *lowercase						:      Tuple    ,							**lowercase						:      Union[str, Any]						)	->	Dict:
				requires_backends(a_    ,							["torch"]						)






def  _lowerCamelCase				( *lowercase						:      Tuple    ,							**lowercase						:      Optional[Any]						)	->	Optional[int]:
				requires_backends(a_    ,							["torch"]						)






def  _lowerCamelCase				( *lowercase						:      Dict    ,							**lowercase						:      List[Any]						)	->	Optional[Any]:
				requires_backends(a_    ,							["torch"]						)






def  _lowerCamelCase				( *lowercase						:      List[str]    ,							**lowercase						:      Tuple						)	->	Union[str, Any]:
				requires_backends(a_    ,							["torch"]						)
class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					int					,				*__a     :					List[Any]					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					str					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Optional[Any]					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					List[Any]					,				**__a     :					Union[str, Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Dict					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Dict					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Dict					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Dict					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					str					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					Optional[int]					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					str					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					str					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					Union[str, Any]					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					Dict					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Union[str, Any]					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Union[str, Any]					,				*__a     :					Tuple					,				**__a     :					Union[str, Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					Tuple					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					int					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Dict					,				**__a     :					Tuple					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Dict					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					Union[str, Any]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					str					,				**__a     :					Dict					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Union[str, Any]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					Union[str, Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Any					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Any					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Dict					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					List[str]					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Optional[int]					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Union[str, Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					List[Any]					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Optional[int]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Any					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Dict					,				*__a     :					Optional[Any]					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Optional[int]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Optional[Any]					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Union[str, Any]					,				*__a     :					Optional[int]					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					int					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					str					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Dict					,				*__a     :					Union[str, Any]					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Any					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Union[str, Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					Any					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					List[Any]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					int					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					Optional[Any]					,				**__a     :					Any					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Union[str, Any]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					str					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					str					,				*__a     :					Any					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Optional[Any]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					List[str]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					Any					,				**__a     :					Tuple					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					List[Any]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Optional[Any]					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					Any					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Union[str, Any]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					int					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					Any					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					int					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Any					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Dict					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					int					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Tuple					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					Optional[int]					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Union[str, Any]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					List[Any]					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					int					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					Optional[Any]					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					List[Any]					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[int]					,				*__a     :					Optional[int]					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					List[str]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Any					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					int					,				*__a     :					Tuple					,				**__a     :					Tuple					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					List[Any]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					List[str]					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					Tuple					,				**__a     :					Any					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					Tuple					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					Any					,				**__a     :					int					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					List[Any]					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					Dict					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Optional[Any]					,				**__a     :					Dict					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					str					,				*__a     :					Any					,				**__a     :					List[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					int					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Optional[int]					,				**__a     :					str					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					Any					,				**__a     :					Optional[int]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Tuple					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Any					,				*__a     :					int					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Dict					,				*__a     :					Optional[Any]					,				**__a     :					Dict					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					List[Any]					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					str					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[Any]					,				*__a     :					Optional[Any]					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					int					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					Tuple					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Dict					,				*__a     :					Tuple					,				**__a     :					List[str]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Union[str, Any]					,				*__a     :					str					,				**__a     :					Tuple					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Dict					,				*__a     :					Any					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Any					,				*__a     :					List[Any]					,				**__a     :					Any					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[int]					,				*__a     :					Optional[int]					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					str					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					List[str]					,				*__a     :					str					,				**__a     :					Union[str, Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					List[str]					,				**__a     :					List[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Optional[Any]					,				*__a     :					Any					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Dict					,				*__a     :					int					,				**__a     :					Optional[Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					int					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					Any					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					List[str]					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Union[str, Any]					,				**__a     :					Union[str, Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					Dict					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					int					,				*__a     :					Tuple					,				**__a     :					str					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					Any					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					str					,				*__a     :					int					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Tuple					,				*__a     :					List[Any]					,				**__a     :					Union[str, Any]					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[str]					,				*__a     :					Optional[int]					,				**__a     :					Optional[Any]					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					List[Any]					,				*__a     :					List[Any]					,				**__a     :					List[str]					):
								requires_backends(cls					,				["torch"]					)


class 				__SCREAMING_SNAKE_CASE  (metaclass=snake_case_      ):






				"""simple docstring"""







				__a            =['torch']




				def __init__(  self     :					Optional[Any]					,				*__a     :					Dict					,				**__a     :					int					):
								requires_backends(self					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					int					,				*__a     :					int					,				**__a     :					Any					):
								requires_backends(cls					,				["torch"]					)




				@classmethod
				def   UpperCamelCase__   (  cls     :					Tuple					,				*__a     :					Dict					,				**__a     :					Optional[int]					):
								requires_backends(cls					,				["torch"]					)








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowercase  							=					{
    "configuration_tapas": ["TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP", "TapasConfig"],
    "tokenization_tapas": ["TapasTokenizer"],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowercase  							=					[
	    "TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "TapasForMaskedLM",
	    "TapasForQuestionAnswering",
	    "TapasForSequenceClassification",
	    "TapasModel",
	    "TapasPreTrainedModel",
	    "load_tf_weights_in_tapas",
	]
try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowercase  							=					[
	    "TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "TFTapasForMaskedLM",
	    "TFTapasForQuestionAnswering",
	    "TFTapasForSequenceClassification",
	    "TFTapasModel",
	    "TFTapasPreTrainedModel",
	]


if TYPE_CHECKING:
	from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
	from .tokenization_tapas import TapasTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tapas import (
		    TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TapasForMaskedLM,
		    TapasForQuestionAnswering,
		    TapasForSequenceClassification,
		    TapasModel,
		    TapasPreTrainedModel,
		    load_tf_weights_in_tapas,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_tapas import (
		    TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFTapasForMaskedLM,
		    TFTapasForQuestionAnswering,
		    TFTapasForSequenceClassification,
		    TFTapasModel,
		    TFTapasPreTrainedModel,
		)


else:
	import sys

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





