


"""simple docstring"""


from typing import TYPE_CHECKING

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


if is_sentencepiece_available():
	from ..ta.tokenization_ta import TaTokenizer
else:
	from ...utils.dummy_sentencepiece_objects import TaTokenizer

A	:  Any            =     TaTokenizer

if is_tokenizers_available():
	from ..ta.tokenization_ta_fast import TaTokenizerFast
else:
	from ...utils.dummy_tokenizers_objects import TaTokenizerFast

A	:  Dict            =     TaTokenizerFast

A	:  Optional[int]            =     {"configuration_mt5": ["MT5Config", "MT5OnnxConfig"]}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A	:  Union[str, Any]            =     [
	    "MT5EncoderModel",
	    "MT5ForConditionalGeneration",
	    "MT5ForQuestionAnswering",
	    "MT5Model",
	    "MT5PreTrainedModel",
	    "MT5Stack",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A	:  int            =     ["TFMT5EncoderModel", "TFMT5ForConditionalGeneration", "TFMT5Model"]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A	:  Any            =     ["FlaxMT5EncoderModel", "FlaxMT5ForConditionalGeneration", "FlaxMT5Model"]


if TYPE_CHECKING:
	from .configuration_mta import MTaConfig, MTaOnnxConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_mta import (
		    MTaEncoderModel,
		    MTaForConditionalGeneration,
		    MTaForQuestionAnswering,
		    MTaModel,
		    MTaPreTrainedModel,
		    MTaStack,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel

else:
	import sys

	A	:  Any            =     _LazyModule(
	    __name__,
	    globals()["__file__"],
	    _import_structure,
	    extra_objects={"MT5Tokenizer": MTaTokenizer, "MT5TokenizerFast": MTaTokenizerFast},
	    module_spec=__spec__,
	)








"""simple docstring"""


from ..utils import DummyObject, requires_backends
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

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

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )




