






import importlib.metadata
import operator
import re
import sys
from typing import Optional

from packaging import version


lowerCamelCase     :							Union[str, Any]    ={
    '''<''': operator.lt,
    '''<=''': operator.le,
    '''==''': operator.eq,
    '''!=''': operator.ne,
    '''>=''': operator.ge,
    '''>''': operator.gt,
}







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )			->     str:
					if got_ver is None or want_ver is None:
										raise ValueError(
										    f'Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider'
										    f' reinstalling {pkg}.'      )
					if not ops[op](version.parse(__lowerCAmelCase      ) ,   version.parse(__lowerCAmelCase      )      ):
										raise ImportError(
										    f'{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}'      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase = None      )			->     None:
					UpperCamelCase__      :       Optional[Any]	    =  f'\n{hint}' if hint is not None else ""

					# non-versioned check
					if re.match(R"^[\w_\-\d]+$" ,   __lowerCAmelCase      ):
										UpperCamelCase__      :       Any	    =  requirement, None, None
					else:
										UpperCamelCase__      :       int	    =  re.findall(R"^([^!=<>\s]+)([\s!=<>]{1,2}.+)" ,   __lowerCAmelCase      )
										if not match:
															raise ValueError(
															    "requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but"
															    f' got {requirement}'      )
										UpperCamelCase__      :       Any	    =  match[0]
										UpperCamelCase__      :       Union[str, Any]	    =  want_full.split(","      )  # there could be multiple requirements
										UpperCamelCase__      :       Optional[Any]	    =  {}
										for w in want_range:
															UpperCamelCase__      :       Tuple	    =  re.findall(R"^([\s!=<>]{1,2})(.+)" ,   __lowerCAmelCase      )
															if not match:
																				raise ValueError(
																				    "requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,"
																				    f' but got {requirement}'      )
															UpperCamelCase__      :       Union[str, Any]	    =  match[0]
															UpperCamelCase__      :       Union[str, Any]	    =  want_ver
															if op not in ops:
																				raise ValueError(f'{requirement}: need one of {list(ops.keys()      )}, but got {op}'      )

    # special case
					if pkg == "python":
										UpperCamelCase__      :       Optional[Any]	    =  ".".join([str(__lowerCAmelCase      ) for x in sys.version_info[:3]]      )
										for op, want_ver in wanted.items():
															_compare_versions(__lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )
										return

					# check if any version is installed
					try:
										UpperCamelCase__      :       Union[str, Any]	    =  importlib.metadata.version(__lowerCAmelCase      )
					except importlib.metadata.PackageNotFoundError:
										raise importlib.metadata.PackageNotFoundError(
										    f'The \'{requirement}\' distribution was not found and is required by this application. {hint}'      )

					# check that the right version is installed if version number or a range was provided
					if want_ver is not None:
										for op, want_ver in wanted.items():
															_compare_versions(__lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Optional[int]:
					UpperCamelCase__      :       List[Any]	    =  "Try: pip install transformers -U or pip install -e '.[dev]' if you're working with git main"
					return require_version(__lowerCAmelCase ,   __lowerCAmelCase      )







from ..utils import DummyObject, requires_backends





class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	str				=			['''torch''']







 def __init__(		self :       int							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[Any]				=			['''torch''']







 def __init__(		self :       Dict							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Union[str, Any]				=			['''torch''']







 def __init__(		self :       Dict							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       str							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Tuple						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       Tuple						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[str]				=			['''torch''']







 def __init__(		self :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Tuple						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Dict				=			['''torch''']







 def __init__(		self :       List[Any]							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Dict				=			['''torch''']







 def __init__(		self :       List[Any]							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Any				=			['''torch''']







 def __init__(		self :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       Optional[int]							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[Any]				=			['''torch''']







 def __init__(		self :       int							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Dict				=			['''torch''']







 def __init__(		self :       Dict							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[Any]							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Optional[int]				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Dict						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







def 		SCREAMING_SNAKE_CASE							( *__lowerCAmelCase ,   **__lowerCAmelCase      )			->     int:
     requires_backends(__lowerCAmelCase ,   ["torch"]      )







def 		SCREAMING_SNAKE_CASE							( *__lowerCAmelCase ,   **__lowerCAmelCase      )			->     Optional[Any]:
     requires_backends(__lowerCAmelCase ,   ["torch"]      )







def 		SCREAMING_SNAKE_CASE							( *__lowerCAmelCase ,   **__lowerCAmelCase      )			->     Optional[Any]:
     requires_backends(__lowerCAmelCase ,   ["torch"]      )







def 		SCREAMING_SNAKE_CASE							( *__lowerCAmelCase ,   **__lowerCAmelCase      )			->     Union[str, Any]:
     requires_backends(__lowerCAmelCase ,   ["torch"]      )







def 		SCREAMING_SNAKE_CASE							( *__lowerCAmelCase ,   **__lowerCAmelCase      )			->     Any:
     requires_backends(__lowerCAmelCase ,   ["torch"]      )







def 		SCREAMING_SNAKE_CASE							( *__lowerCAmelCase ,   **__lowerCAmelCase      )			->     Dict:
     requires_backends(__lowerCAmelCase ,   ["torch"]      )







def 		SCREAMING_SNAKE_CASE							( *__lowerCAmelCase ,   **__lowerCAmelCase      )			->     List[Any]:
     requires_backends(__lowerCAmelCase ,   ["torch"]      )





class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[str]				=			['''torch''']







 def __init__(		self :       Tuple							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Optional[int]				=			['''torch''']







 def __init__(		self :       List[Any]							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       Dict						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	str				=			['''torch''']







 def __init__(		self :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Any				=			['''torch''']







 def __init__(		self :       List[Any]							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[Any]							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	str				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Tuple						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Any				=			['''torch''']







 def __init__(		self :       str							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       Dict							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	int				=			['''torch''']







 def __init__(		self :       Optional[Any]							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Optional[int]				=			['''torch''']







 def __init__(		self :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[str]				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       Optional[int]							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Any				=			['''torch''']







 def __init__(		self :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Any				=			['''torch''']







 def __init__(		self :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Dict						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       str							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Union[str, Any]				=			['''torch''']







 def __init__(		self :       str							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       Tuple						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Any				=			['''torch''']







 def __init__(		self :       int							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Tuple						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Union[str, Any]				=			['''torch''']







 def __init__(		self :       Optional[Any]							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Optional[int]				=			['''torch''']







 def __init__(		self :       int							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[Any]				=			['''torch''']







 def __init__(		self :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Optional[int]				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	str				=			['''torch''']







 def __init__(		self :       List[str]							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       List[Any]							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Optional[int]							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Dict				=			['''torch''']







 def __init__(		self :       Dict							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       str							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Dict				=			['''torch''']







 def __init__(		self :       Optional[Any]							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       Optional[int]							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	str				=			['''torch''']







 def __init__(		self :       Tuple							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[Any]				=			['''torch''']







 def __init__(		self :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Tuple						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Union[str, Any]				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Dict						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	str				=			['''torch''']







 def __init__(		self :       Dict							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       Dict							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Dict				=			['''torch''']







 def __init__(		self :       Optional[Any]							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Union[str, Any]				=			['''torch''']







 def __init__(		self :       Dict							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       List[str]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Any							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Union[str, Any]							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       Tuple						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Dict				=			['''torch''']







 def __init__(		self :       str							,       *SCREAMING_SNAKE_CASE :       Any							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[Any]				=			['''torch''']







 def __init__(		self :       Tuple							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       Dict							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Optional[int]				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       int							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	List[str]				=			['''torch''']







 def __init__(		self :       int							,       *SCREAMING_SNAKE_CASE :       Tuple							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Dict						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[str]							,       *SCREAMING_SNAKE_CASE :       List[str]							,       **SCREAMING_SNAKE_CASE :       Dict						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       List[Any]							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       Dict						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Tuple				=			['''torch''']







 def __init__(		self :       Any							,       *SCREAMING_SNAKE_CASE :       str							,       **SCREAMING_SNAKE_CASE :       Any						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Tuple							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       Optional[Any]							,       **SCREAMING_SNAKE_CASE :       int						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







class       __a  (   metaclass=A__	):
 _lowerCAmelCase	:	Dict				=			['''torch''']







 def __init__(		self :       Optional[int]							,       *SCREAMING_SNAKE_CASE :       List[Any]							,       **SCREAMING_SNAKE_CASE :       str						):


      '''simple docstring'''






      requires_backends(self							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Optional[Any]							,       *SCREAMING_SNAKE_CASE :       int							,       **SCREAMING_SNAKE_CASE :       Union[str, Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)







 @classmethod
 def  __lowercase (		cls :       Dict							,       *SCREAMING_SNAKE_CASE :       Union[str, Any]							,       **SCREAMING_SNAKE_CASE :       Optional[Any]						):


      '''simple docstring'''






      requires_backends(cls							,       ["torch"]						)