'''simple docstring'''

from ..utils import DummyObject, requires_backends







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Tuple				     = ["""vision"""]
 def __init__(				self       :     int				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     Dict							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     Dict				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     str							)  ->   Optional[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     Optional[int]							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     Tuple				,	*SCREAMING_SNAKE_CASE__       :     Tuple				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[int]				     = ["""vision"""]
 def __init__(				self       :     Tuple				,	*SCREAMING_SNAKE_CASE__       :     int				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[str]				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     Any				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     List[str]				,	*SCREAMING_SNAKE_CASE__       :     Union[str, Any]				,	**SCREAMING_SNAKE_CASE__       :     Dict							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   Any:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     int				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     Optional[int]							)  ->   List[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	str				     = ["""vision"""]
 def __init__(				self       :     str				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Tuple				     = ["""vision"""]
 def __init__(				self       :     List[Any]				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     Any							)  ->   Optional[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	str				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     Dict							)  ->   Optional[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     Optional[int]				,	**SCREAMING_SNAKE_CASE__       :     Tuple							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   List[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[Any]				     = ["""vision"""]
 def __init__(				self       :     str				,	*SCREAMING_SNAKE_CASE__       :     Dict				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     str				,	*SCREAMING_SNAKE_CASE__       :     Optional[int]				,	**SCREAMING_SNAKE_CASE__       :     Tuple							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     Any				,	*SCREAMING_SNAKE_CASE__       :     Tuple				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     List[str]				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   List[str]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     Tuple				,	*SCREAMING_SNAKE_CASE__       :     Any				,	**SCREAMING_SNAKE_CASE__       :     Dict							)  ->   List[str]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[int]				     = ["""vision"""]
 def __init__(				self       :     Dict				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[str]				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   Optional[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	str				     = ["""vision"""]
 def __init__(				self       :     Optional[Any]				,	*SCREAMING_SNAKE_CASE__       :     Union[str, Any]				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   List[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     Any				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     List[str]				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	str				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     Any							)  ->   Optional[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     Optional[Any]				,	*SCREAMING_SNAKE_CASE__       :     Dict				,	**SCREAMING_SNAKE_CASE__       :     Optional[int]							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     Dict				,	**SCREAMING_SNAKE_CASE__       :     Any							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     List[Any]				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     str							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     Optional[Any]				,	*SCREAMING_SNAKE_CASE__       :     Any				,	**SCREAMING_SNAKE_CASE__       :     Any							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     int				,	*SCREAMING_SNAKE_CASE__       :     int				,	**SCREAMING_SNAKE_CASE__       :     Tuple							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Union[str, Any]				     = ["""vision"""]
 def __init__(				self       :     str				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     str							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Tuple				     = ["""vision"""]
 def __init__(				self       :     List[Any]				,	*SCREAMING_SNAKE_CASE__       :     Tuple				,	**SCREAMING_SNAKE_CASE__       :     str							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     Optional[Any]				,	*SCREAMING_SNAKE_CASE__       :     Any				,	**SCREAMING_SNAKE_CASE__       :     Union[str, Any]							)  ->   List[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   Optional[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     Dict				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[int]				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     int				,	**SCREAMING_SNAKE_CASE__       :     Any							)  ->   List[str]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     Any				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     Optional[int]							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     Tuple				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[Any]				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     Optional[int]				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Tuple				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     Tuple							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     Any				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[str]				     = ["""vision"""]
 def __init__(				self       :     List[str]				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     Optional[int]							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     List[Any]				,	*SCREAMING_SNAKE_CASE__       :     Dict				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   List[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Union[str, Any]				     = ["""vision"""]
 def __init__(				self       :     List[Any]				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[int]				     = ["""vision"""]
 def __init__(				self       :     List[str]				,	*SCREAMING_SNAKE_CASE__       :     int				,	**SCREAMING_SNAKE_CASE__       :     Tuple							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     List[Any]				,	*SCREAMING_SNAKE_CASE__       :     int				,	**SCREAMING_SNAKE_CASE__       :     Tuple							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     int				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     str							)  ->   Optional[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[int]				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     Union[str, Any]				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     Union[str, Any]				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     Union[str, Any]							)  ->   List[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Union[str, Any]				     = ["""vision"""]
 def __init__(				self       :     Any				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   Any:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[str]				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     List[str]				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[int]				     = ["""vision"""]
 def __init__(				self       :     List[Any]				,	*SCREAMING_SNAKE_CASE__       :     Dict				,	**SCREAMING_SNAKE_CASE__       :     Any							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     int				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     Dict							)  ->   List[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[str]				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     Optional[int]				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Tuple				     = ["""vision"""]
 def __init__(				self       :     Any				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     Any							)  ->   Tuple:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[Any]				     = ["""vision"""]
 def __init__(				self       :     List[Any]				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     Optional[int]							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     Dict				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     List[str]							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     Tuple				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[int]				     = ["""vision"""]
 def __init__(				self       :     Optional[Any]				,	*SCREAMING_SNAKE_CASE__       :     int				,	**SCREAMING_SNAKE_CASE__       :     Union[str, Any]							)  ->   Union[str, Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Tuple				     = ["""vision"""]
 def __init__(				self       :     str				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     Tuple				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     Dict							)  ->   Optional[Any]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   List[str]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	str				     = ["""vision"""]
 def __init__(				self       :     Dict				,	*SCREAMING_SNAKE_CASE__       :     List[str]				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     Tuple				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     Optional[Any]							)  ->   Any:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     Tuple				,	*SCREAMING_SNAKE_CASE__       :     Dict				,	**SCREAMING_SNAKE_CASE__       :     Dict							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Optional[Any]				     = ["""vision"""]
 def __init__(				self       :     Optional[Any]				,	*SCREAMING_SNAKE_CASE__       :     List[Any]				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   Optional[int]:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	str				     = ["""vision"""]
 def __init__(				self       :     Optional[Any]				,	*SCREAMING_SNAKE_CASE__       :     Tuple				,	**SCREAMING_SNAKE_CASE__       :     int							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Any				     = ["""vision"""]
 def __init__(				self       :     Union[str, Any]				,	*SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   Dict:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	Dict				     = ["""vision"""]
 def __init__(				self       :     Optional[int]				,	*SCREAMING_SNAKE_CASE__       :     int				,	**SCREAMING_SNAKE_CASE__       :     List[Any]							)  ->   str:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	List[Any]				     = ["""vision"""]
 def __init__(				self       :     List[str]				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     Dict							)  ->   Any:
  requires_backends(self				,	["""vision"""]							)







class     _lowercase					(    metaclass=UpperCAmelCase__      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	int				     = ["""vision"""]
 def __init__(				self       :     str				,	*SCREAMING_SNAKE_CASE__       :     str				,	**SCREAMING_SNAKE_CASE__       :     str							)  ->   int:
  requires_backends(self				,	["""vision"""]							)







'''simple docstring'''

import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionDualGuidedPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


_A      :				Any 				=    False







@nightly
@require_torch_gpu
class     _lowercase					(    unittest.TestCase      ):


 '''simple docstring'''






 def a (				self       :     Tuple							)  ->   Dict:
  # clean up the VRAM after each test
  super().tearDown()
  gc.collect()
  torch.cuda.empty_cache()
 def a (				self       :     Optional[int]							)  ->   Optional[Any]:
  __lowerCAmelCase    							=						VersatileDiffusionDualGuidedPipeline.from_pretrained("""shi-labs/versatile-diffusion"""							)
  # remove text_unet
  pipe.remove_unused_weights()
  pipe.to(SCREAMING_SNAKE_CASE__							)
  pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

  __lowerCAmelCase    							=						load_image(
      """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"""							)

  __lowerCAmelCase    							=						torch.manual_seed(0							)
  __lowerCAmelCase    							=						pipe(
      prompt="""first prompt"""				,	image=SCREAMING_SNAKE_CASE__				,	text_to_image_strength=0.7_5				,	generator=SCREAMING_SNAKE_CASE__				,	guidance_scale=7.5				,	num_inference_steps=2				,	output_type="""numpy"""				,	).images

  with tempfile.TemporaryDirectory() as tmpdirname:
   pipe.save_pretrained(SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase    							=						VersatileDiffusionDualGuidedPipeline.from_pretrained(SCREAMING_SNAKE_CASE__							)

  pipe.to(SCREAMING_SNAKE_CASE__							)
  pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

  __lowerCAmelCase    							=						generator.manual_seed(0							)
  __lowerCAmelCase    							=						pipe(
      prompt="""first prompt"""				,	image=SCREAMING_SNAKE_CASE__				,	text_to_image_strength=0.7_5				,	generator=SCREAMING_SNAKE_CASE__				,	guidance_scale=7.5				,	num_inference_steps=2				,	output_type="""numpy"""				,	).images

  assert np.abs(image - new_image							).sum() < 1e-5, "Models don't have the same forward pass"





 def a (				self       :     str							)  ->   Tuple:
  __lowerCAmelCase    							=						VersatileDiffusionDualGuidedPipeline.from_pretrained("""shi-labs/versatile-diffusion"""							)
  pipe.remove_unused_weights()
  pipe.to(SCREAMING_SNAKE_CASE__							)
  pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

  __lowerCAmelCase    							=						"""cyberpunk 2077"""
  __lowerCAmelCase    							=						load_image(
      """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"""							)
  __lowerCAmelCase    							=						torch.manual_seed(0							)
  __lowerCAmelCase    							=						pipe(
      prompt=SCREAMING_SNAKE_CASE__				,	image=SCREAMING_SNAKE_CASE__				,	text_to_image_strength=0.7_5				,	generator=SCREAMING_SNAKE_CASE__				,	guidance_scale=7.5				,	num_inference_steps=50				,	output_type="""numpy"""				,	).images

  __lowerCAmelCase    							=						image[0, 2_53:2_56, 2_53:2_56, -1]

  assert image.shape == (1, 5_12, 5_12, 3)
  __lowerCAmelCase    							=						np.array([0.0_7_8_7, 0.0_8_4_9, 0.0_8_2_6, 0.0_8_1_2, 0.0_8_0_7, 0.0_7_9_5, 0.0_8_1_8, 0.0_7_9_8, 0.0_7_7_9]							)

  assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2






