

from ..utils import DummyObject, requires_backends







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Any					=["flax"]


  def __init__(	self			:       List[Any] , *UpperCAmelCase__			:       List[Any] , **UpperCAmelCase__			:       Union[str, Any]						)    ->List[str]:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Optional[Any] , *UpperCAmelCase__			:       List[Any] , **UpperCAmelCase__			:       List[str]						)    ->Optional[int]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Optional[int] , *UpperCAmelCase__			:       Union[str, Any] , **UpperCAmelCase__			:       Dict						)    ->List[Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Optional[int]					=["flax"]


  def __init__(	self			:       Union[str, Any] , *UpperCAmelCase__			:       List[Any] , **UpperCAmelCase__			:       int						)    ->Union[str, Any]:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Optional[Any] , *UpperCAmelCase__			:       Tuple , **UpperCAmelCase__			:       Tuple						)    ->str:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       int , *UpperCAmelCase__			:       List[str] , **UpperCAmelCase__			:       Tuple						)    ->List[Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       str					=["flax"]


  def __init__(	self			:       Any , *UpperCAmelCase__			:       str , **UpperCAmelCase__			:       Optional[int]						)    ->int:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Tuple , *UpperCAmelCase__			:       Optional[Any] , **UpperCAmelCase__			:       Dict						)    ->Tuple:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Optional[Any] , *UpperCAmelCase__			:       str , **UpperCAmelCase__			:       Dict						)    ->Union[str, Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       List[Any]					=["flax"]


  def __init__(	self			:       Optional[int] , *UpperCAmelCase__			:       Optional[int] , **UpperCAmelCase__			:       str						)    ->Optional[Any]:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       str , *UpperCAmelCase__			:       Dict , **UpperCAmelCase__			:       List[str]						)    ->Optional[int]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       List[str] , *UpperCAmelCase__			:       str , **UpperCAmelCase__			:       Tuple						)    ->List[str]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Optional[int]					=["flax"]


  def __init__(	self			:       List[str] , *UpperCAmelCase__			:       Optional[Any] , **UpperCAmelCase__			:       str						)    ->Tuple:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Tuple , *UpperCAmelCase__			:       Any , **UpperCAmelCase__			:       Dict						)    ->Union[str, Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Optional[Any] , *UpperCAmelCase__			:       Any , **UpperCAmelCase__			:       str						)    ->Optional[int]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Dict					=["flax"]


  def __init__(	self			:       str , *UpperCAmelCase__			:       List[Any] , **UpperCAmelCase__			:       Optional[int]						)    ->Tuple:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       str , *UpperCAmelCase__			:       Optional[int] , **UpperCAmelCase__			:       Optional[int]						)    ->Any:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       List[Any] , *UpperCAmelCase__			:       Optional[int] , **UpperCAmelCase__			:       List[str]						)    ->List[str]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Dict					=["flax"]


  def __init__(	self			:       Union[str, Any] , *UpperCAmelCase__			:       List[Any] , **UpperCAmelCase__			:       Any						)    ->Optional[Any]:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Optional[int] , *UpperCAmelCase__			:       Any , **UpperCAmelCase__			:       Tuple						)    ->List[str]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Any , *UpperCAmelCase__			:       List[str] , **UpperCAmelCase__			:       Union[str, Any]						)    ->str:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Union[str, Any]					=["flax"]


  def __init__(	self			:       List[str] , *UpperCAmelCase__			:       Optional[Any] , **UpperCAmelCase__			:       Tuple						)    ->List[str]:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       List[str] , *UpperCAmelCase__			:       Union[str, Any] , **UpperCAmelCase__			:       str						)    ->Tuple:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Union[str, Any] , *UpperCAmelCase__			:       Union[str, Any] , **UpperCAmelCase__			:       int						)    ->int:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Optional[int]					=["flax"]


  def __init__(	self			:       Optional[Any] , *UpperCAmelCase__			:       List[str] , **UpperCAmelCase__			:       int						)    ->Tuple:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Dict , *UpperCAmelCase__			:       List[str] , **UpperCAmelCase__			:       List[Any]						)    ->Optional[Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Dict , *UpperCAmelCase__			:       Optional[Any] , **UpperCAmelCase__			:       List[Any]						)    ->List[Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Optional[Any]					=["flax"]


  def __init__(	self			:       List[str] , *UpperCAmelCase__			:       Tuple , **UpperCAmelCase__			:       str						)    ->Tuple:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Optional[Any] , *UpperCAmelCase__			:       Tuple , **UpperCAmelCase__			:       Optional[int]						)    ->Any:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       List[Any] , *UpperCAmelCase__			:       List[str] , **UpperCAmelCase__			:       Tuple						)    ->Tuple:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Any					=["flax"]


  def __init__(	self			:       Optional[int] , *UpperCAmelCase__			:       str , **UpperCAmelCase__			:       str						)    ->Dict:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Optional[int] , *UpperCAmelCase__			:       int , **UpperCAmelCase__			:       List[Any]						)    ->List[Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Dict , *UpperCAmelCase__			:       List[str] , **UpperCAmelCase__			:       int						)    ->int:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       Optional[Any]					=["flax"]


  def __init__(	self			:       Dict , *UpperCAmelCase__			:       int , **UpperCAmelCase__			:       Any						)    ->Dict:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Union[str, Any] , *UpperCAmelCase__			:       str , **UpperCAmelCase__			:       Tuple						)    ->Union[str, Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Optional[int] , *UpperCAmelCase__			:       Any , **UpperCAmelCase__			:       int						)    ->Union[str, Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)







class 				a__				(      metaclass=UpperCAmelCase				):







  """simple docstring"""




  UpperCAmelCase__					:       int					=["flax"]


  def __init__(	self			:       Any , *UpperCAmelCase__			:       int , **UpperCAmelCase__			:       Dict						)    ->Optional[int]:
        """simple docstring"""







        requires_backends(self , ["""flax"""]						)


  @classmethod
  def        _lowercase					(	cls			:       Union[str, Any] , *UpperCAmelCase__			:       Tuple , **UpperCAmelCase__			:       List[Any]						)    ->List[str]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)




  @classmethod
  def        _lowercase					(	cls			:       Union[str, Any] , *UpperCAmelCase__			:       Dict , **UpperCAmelCase__			:       Any						)    ->List[Any]:
        """simple docstring"""







        requires_backends(cls , ["""flax"""]						)








from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class 	UpperCAmelCase_					(					UpperCamelCase    ):

   '''simple docstring'''




   __A :      Dict     		=		["image_processor", "tokenizer"]
   __A :      Dict     		=		"BridgeTowerImageProcessor"
   __A :      Optional[int]     		=		("RobertaTokenizer", "RobertaTokenizerFast")






   def __init__(		self						,				__A						,				__A ):






     """simple docstring"""





     super().__init__(__A						,				__A )






   def __call__(		self						,				__A						,				__A = None						,				__A = True						,				__A = False						,				__A = None						,				__A = None						,				__A = 0						,				__A = None						,				__A = None						,				__A = None						,				__A = False						,				__A = False						,				__A = False						,				__A = False						,				__A = True						,				__A = None						,				**__A						,				):






     """simple docstring"""





     lowerCamelCase :					str    =				self.tokenizer(
         text=__A						,				add_special_tokens=__A						,				padding=__A						,				truncation=__A						,				max_length=__A						,				stride=__A						,				pad_to_multiple_of=__A						,				return_token_type_ids=__A						,				return_attention_mask=__A						,				return_overflowing_tokens=__A						,				return_special_tokens_mask=__A						,				return_offsets_mapping=__A						,				return_length=__A						,				verbose=__A						,				return_tensors=__A						,				**__A						,				)
     # add pixel_values + pixel_mask
     lowerCamelCase :					int    =				self.image_processor(
         __A						,				return_tensors=__A						,				do_normalize=__A						,				do_center_crop=__A						,				**__A )
     encoding.update(__A )

     return encoding






   def _snake_case    (		self						,				*__A						,				**__A ):






     """simple docstring"""





     return self.tokenizer.batch_decode(*__A						,				**__A )






   def _snake_case    (		self						,				*__A						,				**__A ):






     """simple docstring"""





     return self.tokenizer.decode(*__A						,				**__A )






   @property
   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					List[Any]    =				self.tokenizer.model_input_names
     lowerCamelCase :					int    =				self.image_processor.model_input_names
     return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )



