code: 
  
  
  
  
  from ..utils import DummyObject, requires_backends
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: int			,				*snake_case_		: Dict			,				**snake_case_		: List[str]   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Union[str, Any]			,				*snake_case_		: List[str]			,				**snake_case_		: int   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: Any			,				**snake_case_		: List[str]   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: int			,				*snake_case_		: Any			,				**snake_case_		: Tuple   )   ->							List[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: List[Any]			,				**snake_case_		: Tuple   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: Dict			,				**snake_case_		: Dict   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[Any]			,				*snake_case_		: Optional[int]			,				**snake_case_		: Any   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Any			,				*snake_case_		: Optional[int]			,				**snake_case_		: Tuple   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: Optional[Any]			,				**snake_case_		: str   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[Any]			,				*snake_case_		: Tuple			,				**snake_case_		: str   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Any			,				*snake_case_		: Any			,				**snake_case_		: Optional[Any]   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[Any]			,				*snake_case_		: List[Any]			,				**snake_case_		: int   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: str			,				**snake_case_		: List[str]   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Dict			,				**snake_case_		: Union[str, Any]   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Any			,				*snake_case_		: List[Any]			,				**snake_case_		: Any   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Tuple			,				*snake_case_		: Tuple			,				**snake_case_		: List[str]   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Tuple			,				*snake_case_		: Optional[Any]			,				**snake_case_		: Optional[Any]   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: str			,				**snake_case_		: Optional[Any]   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: Optional[int]			,				**snake_case_		: int   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Any			,				*snake_case_		: str			,				**snake_case_		: Optional[int]   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Any			,				*snake_case_		: Union[str, Any]			,				**snake_case_		: str   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: Any			,				**snake_case_		: List[str]   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Union[str, Any]			,				*snake_case_		: List[Any]			,				**snake_case_		: Optional[Any]   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Tuple			,				*snake_case_		: Tuple			,				**snake_case_		: Optional[Any]   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: int			,				**snake_case_		: List[Any]   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Any			,				*snake_case_		: Any			,				**snake_case_		: List[Any]   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Dict			,				**snake_case_		: List[str]   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Tuple			,				**snake_case_		: str   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Tuple			,				*snake_case_		: List[Any]			,				**snake_case_		: Dict   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Union[str, Any]			,				*snake_case_		: Any			,				**snake_case_		: Optional[Any]   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Tuple			,				*snake_case_		: Tuple			,				**snake_case_		: Optional[int]   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: Any			,				**snake_case_		: List[str]   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: Dict			,				**snake_case_		: Optional[int]   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: Union[str, Any]			,				**snake_case_		: Dict   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: int			,				**snake_case_		: Union[str, Any]   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: int			,				*snake_case_		: List[str]			,				**snake_case_		: List[Any]   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Tuple			,				**snake_case_		: str   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: List[Any]			,				**snake_case_		: int   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[Any]			,				*snake_case_		: str			,				**snake_case_		: Optional[Any]   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: Optional[int]			,				**snake_case_		: List[str]   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: List[Any]			,				**snake_case_		: Optional[int]   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Union[str, Any]			,				*snake_case_		: int			,				**snake_case_		: Optional[Any]   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[Any]			,				*snake_case_		: Tuple			,				**snake_case_		: Dict   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: Optional[int]			,				**snake_case_		: List[str]   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Any			,				*snake_case_		: str			,				**snake_case_		: str   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[Any]			,				*snake_case_		: Union[str, Any]			,				**snake_case_		: Union[str, Any]   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[Any]			,				*snake_case_		: Dict			,				**snake_case_		: Tuple   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: int			,				*snake_case_		: List[str]			,				**snake_case_		: List[Any]   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: List[str]			,				**snake_case_		: Tuple   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Union[str, Any]			,				**snake_case_		: Tuple   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: int			,				**snake_case_		: Any   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Optional[Any]			,				**snake_case_		: Optional[int]   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: Tuple			,				**snake_case_		: int   )   ->							List[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[Any]			,				*snake_case_		: Any			,				**snake_case_		: Optional[Any]   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: int			,				**snake_case_		: Optional[int]   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: str			,				**snake_case_		: Optional[Any]   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: Union[str, Any]			,				**snake_case_		: str   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: Any			,				**snake_case_		: Dict   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: int			,				*snake_case_		: List[Any]			,				**snake_case_		: Optional[Any]   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: int			,				*snake_case_		: Tuple			,				**snake_case_		: int   )   ->							List[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Tuple			,				*snake_case_		: Dict			,				**snake_case_		: List[Any]   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: int			,				*snake_case_		: Optional[Any]			,				**snake_case_		: Union[str, Any]   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Tuple			,				*snake_case_		: int			,				**snake_case_		: List[str]   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Union[str, Any]			,				**snake_case_		: Dict   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[Any]			,				*snake_case_		: Optional[int]			,				**snake_case_		: Any   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: List[str]			,				**snake_case_		: int   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[Any]			,				*snake_case_		: Tuple			,				**snake_case_		: List[Any]   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[Any]			,				*snake_case_		: Optional[int]			,				**snake_case_		: str   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Optional[int]			,				*snake_case_		: Optional[int]			,				**snake_case_		: int   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: List[str]			,				*snake_case_		: str			,				**snake_case_		: Optional[Any]   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Tuple			,				**snake_case_		: Optional[int]   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: str			,				*snake_case_		: Any			,				**snake_case_		: Any   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: int			,				*snake_case_		: Tuple			,				**snake_case_		: List[Any]   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		metaclass=snake_case__							):
      lowercase__		      =   ['''vision''']
  
  
  
  
      def __init__(					self		: Dict			,				*snake_case_		: Tuple			,				**snake_case_		: str   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       requires_backends(self			,				["vision"]   )
  
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
  
  
  SCREAMING_SNAKE_CASE       = {
      "configuration_deta": ["DETA_PRETRAINED_CONFIG_ARCHIVE_MAP", "DetaConfig"],
  }
  
  try:
        if not is_vision_available():
              raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
        pass
  else:
        SCREAMING_SNAKE_CASE       = ["DetaImageProcessor"]
  
  try:
        if not is_torch_available():
              raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
        pass
  else:
        SCREAMING_SNAKE_CASE       = [
            "DETA_PRETRAINED_MODEL_ARCHIVE_LIST",
            "DetaForObjectDetection",
            "DetaModel",
            "DetaPreTrainedModel",
        ]
  
  
  if TYPE_CHECKING:
        from .configuration_deta import DETA_PRETRAINED_CONFIG_ARCHIVE_MAP, DetaConfig
  
        try:
              if not is_vision_available():
                    raise OptionalDependencyNotAvailable()
        except OptionalDependencyNotAvailable:
              pass
        else:
              from .image_processing_deta import DetaImageProcessor
  
        try:
              if not is_torch_available():
                    raise OptionalDependencyNotAvailable()
        except OptionalDependencyNotAvailable:
              pass
        else:
              from .modeling_deta import (
                  DETA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DetaForObjectDetection,
                  DetaModel,
                  DetaPreTrainedModel,
              )
  
  else:
        import sys
  
        SCREAMING_SNAKE_CASE       = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  
  
  
  
  