





from ..utils import DummyObject, requires_backends







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    str							,				*A :    Tuple							,				**A :    Optional[int]		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Dict							,				*A :    Dict							,				**A :    Optional[int]		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Tuple							,				*A :    Union[str, Any]							,				**A :    int		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Any							,				*A :    str							,				**A :    Optional[Any]		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Any							,				*A :    Tuple							,				**A :    Optional[int]		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    str							,				*A :    Optional[Any]							,				**A :    Tuple		):
         requires_backends(cls							,				["""torch"""]		)






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Tuple							,				*A :    List[Any]							,				**A :    int		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    str							,				*A :    Tuple							,				**A :    str		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Any							,				*A :    str							,				**A :    str		):
         requires_backends(cls							,				["""torch"""]		)






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Union[str, Any]							,				*A :    List[Any]							,				**A :    int		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







def 			A__							(    *SCREAMING_SNAKE_CASE__					,					**SCREAMING_SNAKE_CASE__)   ->    int:
  requires_backends(__lowercase					,					["""torch"""])







def 			A__							(    *SCREAMING_SNAKE_CASE__					,					**SCREAMING_SNAKE_CASE__)   ->    str:
  requires_backends(__lowercase					,					["""torch"""])







def 			A__							(    *SCREAMING_SNAKE_CASE__					,					**SCREAMING_SNAKE_CASE__)   ->    Optional[int]:
  requires_backends(__lowercase					,					["""torch"""])







def 			A__							(    *SCREAMING_SNAKE_CASE__					,					**SCREAMING_SNAKE_CASE__)   ->    List[Any]:
  requires_backends(__lowercase					,					["""torch"""])







def 			A__							(    *SCREAMING_SNAKE_CASE__					,					**SCREAMING_SNAKE_CASE__)   ->    int:
  requires_backends(__lowercase					,					["""torch"""])







def 			A__							(    *SCREAMING_SNAKE_CASE__					,					**SCREAMING_SNAKE_CASE__)   ->    str:
  requires_backends(__lowercase					,					["""torch"""])







def 			A__							(    *SCREAMING_SNAKE_CASE__					,					**SCREAMING_SNAKE_CASE__)   ->    Tuple:
  requires_backends(__lowercase					,					["""torch"""])







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    List[Any]							,				*A :    Optional[Any]							,				**A :    Tuple		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Union[str, Any]							,				*A :    Optional[int]							,				**A :    Dict		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    List[Any]							,				*A :    Tuple							,				**A :    int		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Dict							,				*A :    str							,				**A :    Optional[Any]		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Tuple							,				*A :    Tuple							,				**A :    str		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




       def __init__(  self :    Dict							,				*A :    Tuple							,				**A :    Tuple		):
         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[int]							,				*A :    Optional[Any]							,				**A :    Optional[Any]		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Union[str, Any]							,				*A :    Tuple							,				**A :    Dict		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Optional[Any]							,				*A :    Optional[int]							,				**A :    Tuple		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    List[str]							,				*A :    Dict							,				**A :    Optional[int]		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    str							,				*A :    Dict							,				**A :    int		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Tuple							,				*A :    Optional[Any]							,				**A :    List[Any]		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Optional[Any]							,				*A :    str							,				**A :    str		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Optional[Any]							,				*A :    Union[str, Any]							,				**A :    Dict		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    int							,				*A :    Optional[int]							,				**A :    Optional[int]		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Dict							,				*A :    int							,				**A :    int		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    str							,				*A :    str							,				**A :    str		):
         requires_backends(cls							,				["""torch"""]		)






       @classmethod
       def 							UpperCAmelCase__ (  cls :    List[str]							,				*A :    Optional[int]							,				**A :    List[str]		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Optional[int]							,				*A :    Any							,				**A :    Tuple		):
         requires_backends(cls							,				["""torch"""]		)






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Optional[Any]							,				*A :    str							,				**A :    Dict		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Tuple							,				*A :    Optional[Any]							,				**A :    int		):
         requires_backends(cls							,				["""torch"""]		)






       @classmethod
       def 							UpperCAmelCase__ (  cls :    List[Any]							,				*A :    Tuple							,				**A :    Optional[int]		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




       @classmethod
       def 							UpperCAmelCase__ (  cls :    Optional[int]							,				*A :    Tuple							,				**A :    List[str]		):
         requires_backends(cls							,				["""torch"""]		)






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Tuple							,				*A :    int							,				**A :    List[str]		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Optional[Any]							,				*A :    str							,				**A :    Optional[Any]		):
         requires_backends(cls							,				["""torch"""]		)







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






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







class     __snake_case       (							metaclass=__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     ["torch"]




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




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






       @classmethod
       def 							UpperCAmelCase__ (  cls :    Dict							,				*A :    str							,				**A :    Tuple		):
         requires_backends(cls							,				["""torch"""]		)








import tempfile
import unittest

from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
from transformers.testing_utils import (
    is_torch_available,
    require_optimum,
    require_torch,
    slow,
)


if is_torch_available():
			import torch




@require_torch
@require_optimum
@slow
class    SCREAMING_SNAKE_CASE__     (	unittest.TestCase					):





	'''simple docstring'''



	def  A							(  self	:    Optional[int]	):


				'''simple docstring'''


				_snake_case		=			'hf-internal-testing/tiny-random-t5'
				_snake_case		=			AutoTokenizer.from_pretrained(lowercase	)
				_snake_case		=			AutoModelForSeqaSeqLM.from_pretrained(lowercase	)

				_snake_case		=			tokenizer('This is me'			,  return_tensors='pt'	)

				_snake_case		=			model.to_bettertransformer()

				self.assertTrue(any('BetterTransformer' in mod.__class__.__name__ for _, mod in model.named_modules()	)	)

				_snake_case		=			model.generate(**lowercase	)

				_snake_case		=			model.reverse_bettertransformer()

				self.assertFalse(any('BetterTransformer' in mod.__class__.__name__ for _, mod in model.named_modules()	)	)

				with tempfile.TemporaryDirectory() as tmpdirname:
							model.save_pretrained(lowercase	)

							_snake_case		=			AutoModelForSeqaSeqLM.from_pretrained(lowercase	)

							self.assertFalse(
							    any('BetterTransformer' in mod.__class__.__name__ for _, mod in model_reloaded.named_modules()	)	)

							_snake_case		=			model_reloaded.generate(**lowercase	)
							self.assertTrue(torch.allclose(lowercase			,  lowercase	)	)





	def  A							(  self	:    List[Any]	):


				'''simple docstring'''


				_snake_case		=			'hf-internal-testing/tiny-random-t5'
				_snake_case		=			AutoModelForSeqaSeqLM.from_pretrained(lowercase	)

				_snake_case		=			model.to_bettertransformer()

				with tempfile.TemporaryDirectory() as tmpdirname:
							with self.assertRaises(lowercase	):
										model.save_pretrained(lowercase	)

							_snake_case		=			model.reverse_bettertransformer()
							model.save_pretrained(lowercase	)