




from ..utils import DummyObject, requires_backends







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Optional[Any]						,				*A :       str						,				**A :       Optional[int]    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Optional[int]						,				*A :       List[Any]						,				**A :       int    )			->			Optional[int]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       List[str]						,				**A :       Union[str, Any]    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       int						,				*A :       Dict						,				**A :       int    )			->			Dict:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       Optional[int]						,				*A :       Dict						,				**A :       Union[str, Any]    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Optional[int]						,				*A :       str						,				**A :       Optional[int]    )			->			str:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Union[str, Any]						,				*A :       Dict						,				**A :       Union[str, Any]    )			->			Optional[int]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       List[str]						,				*A :       List[str]						,				**A :       str    )			->			List[str]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Any						,				*A :       int						,				**A :       Dict    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Any						,				*A :       str						,				**A :       str    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Any						=    ["""vision"""]

     def __init__(      self :       str						,				*A :       Tuple						,				**A :       int    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Optional[int]						,				*A :       Dict						,				**A :       Optional[Any]    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       List[Any]						,				*A :       Dict						,				**A :       Any    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Any						=    ["""vision"""]

     def __init__(      self :       Tuple						,				*A :       List[str]						,				**A :       List[str]    )			->			Union[str, Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       Union[str, Any]						,				**A :       Tuple    )			->			Dict:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       List[Any]						,				*A :       Union[str, Any]						,				**A :       List[str]    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       List[str]						,				**A :       List[str]    )			->			Union[str, Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

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






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       List[Any]						,				*A :       Dict						,				**A :       List[str]    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Union[str, Any]						,				*A :       Dict						,				**A :       Optional[int]    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Dict						=    ["""vision"""]

     def __init__(      self :       List[Any]						,				*A :       Optional[int]						,				**A :       Optional[Any]    )			->			Optional[int]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Union[str, Any]						,				*A :       List[str]						,				**A :       Tuple    )			->			List[str]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Dict						=    ["""vision"""]

     def __init__(      self :       Any						,				*A :       str						,				**A :       str    )			->			Optional[int]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Tuple						,				*A :       int						,				**A :       List[Any]    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       str						,				*A :       List[Any]						,				**A :       Optional[int]    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Dict						=    ["""vision"""]

     def __init__(      self :       List[str]						,				*A :       Optional[Any]						,				**A :       Tuple    )			->			Union[str, Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Optional[int]						,				*A :       Optional[Any]						,				**A :       List[Any]    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       str						,				*A :       List[str]						,				**A :       Union[str, Any]    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Any						=    ["""vision"""]

     def __init__(      self :       Optional[int]						,				*A :       Optional[int]						,				**A :       Tuple    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       Tuple						,				**A :       List[str]    )			->			int:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       List[Any]						,				*A :       Optional[int]						,				**A :       str    )			->			Dict:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Union[str, Any]						,				*A :       int						,				**A :       int    )			->			int:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       Optional[int]						,				*A :       str						,				**A :       Any    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       List[Any]						,				*A :       str						,				**A :       Optional[Any]    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Dict						,				*A :       Optional[int]						,				**A :       Optional[int]    )			->			Union[str, Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       str						,				*A :       Any						,				**A :       Dict    )			->			List[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       Any						,				**A :       Dict    )			->			str:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Union[str, Any]						,				*A :       int						,				**A :       Dict    )			->			int:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Any						=    ["""vision"""]

     def __init__(      self :       int						,				*A :       Optional[Any]						,				**A :       Tuple    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       List[str]						,				*A :       Tuple						,				**A :       Dict    )			->			List[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Dict						=    ["""vision"""]

     def __init__(      self :       List[str]						,				*A :       List[str]						,				**A :       Tuple    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       str						,				*A :       str						,				**A :       Tuple    )			->			Dict:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       List[str]						,				*A :       List[Any]						,				**A :       Union[str, Any]    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Dict						=    ["""vision"""]

     def __init__(      self :       List[Any]						,				*A :       List[str]						,				**A :       List[Any]    )			->			List[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Optional[int]						,				*A :       Union[str, Any]						,				**A :       int    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       Optional[int]						,				**A :       Dict    )			->			List[str]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       Optional[Any]						,				**A :       int    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Tuple						,				*A :       List[str]						,				**A :       List[Any]    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Any						,				*A :       Optional[Any]						,				**A :       Tuple    )			->			Dict:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Dict						=    ["""vision"""]

     def __init__(      self :       List[Any]						,				*A :       Optional[int]						,				**A :       Optional[int]    )			->			str:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       str						,				*A :       Optional[Any]						,				**A :       Optional[Any]    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: int						=    ["""vision"""]

     def __init__(      self :       List[str]						,				*A :       Tuple						,				**A :       Any    )			->			Optional[int]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       Optional[int]						,				*A :       Optional[Any]						,				**A :       Optional[int]    )			->			List[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Optional[Any]						,				*A :       int						,				**A :       Optional[int]    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Dict						=    ["""vision"""]

     def __init__(      self :       Optional[Any]						,				*A :       Optional[int]						,				**A :       str    )			->			Union[str, Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Dict						,				*A :       Any						,				**A :       Union[str, Any]    )			->			List[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Union[str, Any]						,				*A :       Optional[int]						,				**A :       int    )			->			Dict:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       int						,				**A :       Dict    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       str						,				*A :       Union[str, Any]						,				**A :       str    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       Tuple						,				*A :       Optional[Any]						,				**A :       Optional[int]    )			->			Optional[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       str						,				*A :       int						,				**A :       Optional[int]    )			->			List[str]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       List[Any]						,				*A :       Dict						,				**A :       Optional[Any]    )			->			int:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: str						=    ["""vision"""]

     def __init__(      self :       Optional[Any]						,				*A :       int						,				**A :       Dict    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Dict						,				*A :       List[Any]						,				**A :       Optional[int]    )			->			List[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Optional[int]						,				*A :       Dict						,				**A :       List[str]    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: int						=    ["""vision"""]

     def __init__(      self :       Dict						,				*A :       List[Any]						,				**A :       Any    )			->			Tuple:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

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






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       int						,				*A :       Dict						,				**A :       Any    )			->			int:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       str						,				*A :       str						,				**A :       List[str]    )			->			int:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Any						,				*A :       List[Any]						,				**A :       Optional[Any]    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Tuple						,				*A :       Optional[Any]						,				**A :       Union[str, Any]    )			->			Union[str, Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



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

     def __init__(      self :       Optional[int]						,				*A :       List[Any]						,				**A :       Dict    )			->			List[Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       str						,				*A :       Tuple						,				**A :       Any    )			->			Any:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )







class 		__UpperCAmelCase(		metaclass=lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    ["""vision"""]

     def __init__(      self :       List[str]						,				*A :       Dict						,				**A :       int    )			->			Union[str, Any]:






         """simple docstring"""
         requires_backends(self						,				["""vision"""]    )












from typing import TYPE_CHECKING

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


SCREAMING_SNAKE_CASE_						:					List[str]			   =       {'''configuration_vit_hybrid''': ['''VIT_HYBRID_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ViTHybridConfig''']}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_						:					Tuple			   =       [
     '''VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''ViTHybridForImageClassification''',
     '''ViTHybridModel''',
     '''ViTHybridPreTrainedModel''',
 ]

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_						:					int			   =       ['''ViTHybridImageProcessor''']


if TYPE_CHECKING:
 from .configuration_vit_hybrid import VIT_HYBRID_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTHybridConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_vit_hybrid import (
      VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST,
      ViTHybridForImageClassification,
      ViTHybridModel,
      ViTHybridPreTrainedModel,
  )

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .image_processing_vit_hybrid import ViTHybridImageProcessor


else:
 import sys

 SCREAMING_SNAKE_CASE_						:					Any			   =       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






