





from ..utils import DummyObject, requires_backends

class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Union[str, Any]     ,	*UpperCAmelCase    : Dict     ,	**UpperCAmelCase    : Optional[int]      )     ->      Any:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : Dict     ,	*UpperCAmelCase    : str     ,	**UpperCAmelCase    : List[str]      )     ->      Tuple:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Union[str, Any]     ,	*UpperCAmelCase    : List[str]     ,	**UpperCAmelCase    : int      )     ->      List[Any]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : str     ,	*UpperCAmelCase    : Tuple     ,	**UpperCAmelCase    : Dict      )     ->      List[str]:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : List[str]     ,	*UpperCAmelCase    : Optional[int]     ,	**UpperCAmelCase    : int      )     ->      Any:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : List[Any]     ,	*UpperCAmelCase    : List[Any]     ,	**UpperCAmelCase    : str      )     ->      List[Any]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Any     ,	*UpperCAmelCase    : List[str]     ,	**UpperCAmelCase    : Any      )     ->      Dict:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : int     ,	*UpperCAmelCase    : Tuple     ,	**UpperCAmelCase    : Optional[Any]      )     ->      str:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Optional[int]     ,	*UpperCAmelCase    : str     ,	**UpperCAmelCase    : int      )     ->      Optional[Any]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Optional[int]     ,	*UpperCAmelCase    : str     ,	**UpperCAmelCase    : List[str]      )     ->      Tuple:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : Dict     ,	*UpperCAmelCase    : List[Any]     ,	**UpperCAmelCase    : Optional[int]      )     ->      Optional[Any]:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Optional[Any]     ,	*UpperCAmelCase    : int     ,	**UpperCAmelCase    : Tuple      )     ->      Tuple:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : List[str]     ,	*UpperCAmelCase    : int     ,	**UpperCAmelCase    : Any      )     ->      Tuple:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : Union[str, Any]     ,	*UpperCAmelCase    : List[str]     ,	**UpperCAmelCase    : List[Any]      )     ->      Union[str, Any]:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : int     ,	*UpperCAmelCase    : Union[str, Any]     ,	**UpperCAmelCase    : Any      )     ->      List[str]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Optional[int]     ,	*UpperCAmelCase    : List[str]     ,	**UpperCAmelCase    : Optional[Any]      )     ->      Optional[Any]:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : str     ,	*UpperCAmelCase    : List[str]     ,	**UpperCAmelCase    : Union[str, Any]      )     ->      Any:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Optional[Any]     ,	*UpperCAmelCase    : List[str]     ,	**UpperCAmelCase    : Tuple      )     ->      List[Any]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : List[str]     ,	*UpperCAmelCase    : int     ,	**UpperCAmelCase    : List[Any]      )     ->      Optional[Any]:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : Dict     ,	*UpperCAmelCase    : Any     ,	**UpperCAmelCase    : int      )     ->      Optional[Any]:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Optional[Any]     ,	*UpperCAmelCase    : Tuple     ,	**UpperCAmelCase    : Optional[Any]      )     ->      List[Any]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Dict     ,	*UpperCAmelCase    : int     ,	**UpperCAmelCase    : Dict      )     ->      List[Any]:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : Dict     ,	*UpperCAmelCase    : Optional[Any]     ,	**UpperCAmelCase    : List[Any]      )     ->      List[Any]:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : int     ,	*UpperCAmelCase    : List[str]     ,	**UpperCAmelCase    : Union[str, Any]      )     ->      List[Any]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Tuple     ,	*UpperCAmelCase    : str     ,	**UpperCAmelCase    : Union[str, Any]      )     ->      List[Any]:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : List[Any]     ,	*UpperCAmelCase    : Dict     ,	**UpperCAmelCase    : Any      )     ->      Optional[Any]:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Optional[int]     ,	*UpperCAmelCase    : List[str]     ,	**UpperCAmelCase    : List[Any]      )     ->      Optional[int]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : List[Any]     ,	*UpperCAmelCase    : List[Any]     ,	**UpperCAmelCase    : Optional[int]      )     ->      Optional[int]:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : Any     ,	*UpperCAmelCase    : Any     ,	**UpperCAmelCase    : List[str]      )     ->      int:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Optional[int]     ,	*UpperCAmelCase    : Optional[Any]     ,	**UpperCAmelCase    : List[Any]      )     ->      Any:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Dict     ,	*UpperCAmelCase    : Dict     ,	**UpperCAmelCase    : int      )     ->      Union[str, Any]:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : Tuple     ,	*UpperCAmelCase    : str     ,	**UpperCAmelCase    : Any      )     ->      Any:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : str     ,	*UpperCAmelCase    : Union[str, Any]     ,	**UpperCAmelCase    : List[str]      )     ->      str:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Any     ,	*UpperCAmelCase    : Optional[int]     ,	**UpperCAmelCase    : List[Any]      )     ->      Union[str, Any]:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : int     ,	*UpperCAmelCase    : Any     ,	**UpperCAmelCase    : Tuple      )     ->      Any:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Optional[int]     ,	*UpperCAmelCase    : Optional[Any]     ,	**UpperCAmelCase    : Union[str, Any]      )     ->      List[str]:
     requires_backends(cls     ,	['flax']      )


class   lowerCAmelCase				(   metaclass=UpperCAmelCase_     ):
 UpperCAmelCase__						=						["flax"]
 def __init__( self    : Union[str, Any]     ,	*UpperCAmelCase    : Tuple     ,	**UpperCAmelCase    : Union[str, Any]      )     ->      Any:
     requires_backends(self     ,	['flax']      )
 @classmethod
 def 	A_      ( cls    : int     ,	*UpperCAmelCase    : str     ,	**UpperCAmelCase    : Dict      )     ->      Optional[int]:
     requires_backends(cls     ,	['flax']      )







 @classmethod
 def 	A_      ( cls    : Tuple     ,	*UpperCAmelCase    : int     ,	**UpperCAmelCase    : Optional[int]      )     ->      Union[str, Any]:
     requires_backends(cls     ,	['flax']      )










import warnings

from ...utils import logging
from .image_processing_clip import CLIPImageProcessor


SCREAMING_SNAKE_CASE__   			=   logging.get_logger(__name__)


class   __lowerCAmelCase  (		UpperCAmelCase_   ):
					"""simple docstring"""






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






								"""simple docstring"""


								warnings.warn(
								    'The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'
								    ' use CLIPImageProcessor instead.'					,       _snake_case					,       )
								super().__init__(*_snake_case					,       **_snake_case       )




