import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch
       from torch import nn

       from transformers import MaskFormerSwinBackbone
       from transformers.models.maskformer import MaskFormerSwinModel


class 			UpperCAmelCase__    :



  """simple docstring"""






  def __init__(				self:			Optional[int]				,				__lowerCAmelCase:			List[Any]				,				__lowerCAmelCase:			str=13				,				__lowerCAmelCase:			Optional[int]=32				,				__lowerCAmelCase:			int=2				,				__lowerCAmelCase:			List[str]=3				,				__lowerCAmelCase:			Optional[Any]=16				,				__lowerCAmelCase:			str=[1, 2, 1]				,				__lowerCAmelCase:			Tuple=[2, 2, 4]				,				__lowerCAmelCase:			Union[str, Any]=2				,				__lowerCAmelCase:			str=2.0				,				__lowerCAmelCase:			Tuple=True				,				__lowerCAmelCase:			Optional[Any]=0.0				,				__lowerCAmelCase:			Any=0.0				,				__lowerCAmelCase:			Tuple=0.1				,				__lowerCAmelCase:			Optional[Any]="gelu"				,				__lowerCAmelCase:			int=False				,				__lowerCAmelCase:			List[str]=True				,				__lowerCAmelCase:			List[Any]=0.02				,				__lowerCAmelCase:			List[str]=1E-5				,				__lowerCAmelCase:			str=True				,				__lowerCAmelCase:			int=None				,				__lowerCAmelCase:			str=True				,				__lowerCAmelCase:			Optional[Any]=10				,				__lowerCAmelCase:			Optional[int]=8				,				__lowerCAmelCase:			Optional[int]=["stage1", "stage2", "stage3"]				,				__lowerCAmelCase:			Any=[1, 2, 3]				,				) -> Dict:




    '''simple docstring'''




    __UpperCAmelCase						    =       parent
    __UpperCAmelCase						    =       batch_size
    __UpperCAmelCase						    =       image_size
    __UpperCAmelCase						    =       patch_size
    __UpperCAmelCase						    =       num_channels
    __UpperCAmelCase						    =       embed_dim
    __UpperCAmelCase						    =       depths
    __UpperCAmelCase						    =       num_heads
    __UpperCAmelCase						    =       window_size
    __UpperCAmelCase						    =       mlp_ratio
    __UpperCAmelCase						    =       qkv_bias
    __UpperCAmelCase						    =       hidden_dropout_prob
    __UpperCAmelCase						    =       attention_probs_dropout_prob
    __UpperCAmelCase						    =       drop_path_rate
    __UpperCAmelCase						    =       hidden_act
    __UpperCAmelCase						    =       use_absolute_embeddings
    __UpperCAmelCase						    =       patch_norm
    __UpperCAmelCase						    =       layer_norm_eps
    __UpperCAmelCase						    =       initializer_range
    __UpperCAmelCase						    =       is_training
    __UpperCAmelCase						    =       scope
    __UpperCAmelCase						    =       use_labels
    __UpperCAmelCase						    =       type_sequence_label_size
    __UpperCAmelCase						    =       encoder_stride
    __UpperCAmelCase						    =       out_features
    __UpperCAmelCase						    =       out_indices






  def 	_UpperCAmelCase				(				self:			List[Any]   ) -> Union[str, Any]:




    '''simple docstring'''




    __UpperCAmelCase						    =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

    __UpperCAmelCase						    =       None
    if self.use_labels:
      __UpperCAmelCase						    =       ids_tensor([self.batch_size]				,				self.type_sequence_label_size   )

    __UpperCAmelCase						    =       self.get_config()

    return config, pixel_values, labels






  def 	_UpperCAmelCase				(				self:			Dict   ) -> List[Any]:




    '''simple docstring'''




    return MaskFormerSwinConfig(
        image_size=self.image_size				,				patch_size=self.patch_size				,				num_channels=self.num_channels				,				embed_dim=self.embed_dim				,				depths=self.depths				,				num_heads=self.num_heads				,				window_size=self.window_size				,				mlp_ratio=self.mlp_ratio				,				qkv_bias=self.qkv_bias				,				hidden_dropout_prob=self.hidden_dropout_prob				,				attention_probs_dropout_prob=self.attention_probs_dropout_prob				,				drop_path_rate=self.drop_path_rate				,				hidden_act=self.hidden_act				,				use_absolute_embeddings=self.use_absolute_embeddings				,				path_norm=self.patch_norm				,				layer_norm_eps=self.layer_norm_eps				,				initializer_range=self.initializer_range				,				encoder_stride=self.encoder_stride				,				out_features=self.out_features				,				out_indices=self.out_indices				,				)






  def 	_UpperCAmelCase				(				self:			Dict				,				__lowerCAmelCase:			Optional[int]				,				__lowerCAmelCase:			Any				,				__lowerCAmelCase:			List[str]   ) -> int:




    '''simple docstring'''




    __UpperCAmelCase						    =       MaskFormerSwinModel(config=__lowerCAmelCase   )
    model.to(__lowerCAmelCase   )
    model.eval()
    __UpperCAmelCase						    =       model(__lowerCAmelCase   )

    __UpperCAmelCase						    =       ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
    __UpperCAmelCase						    =       int(config.embed_dim * 2 ** (len(config.depths   ) - 1)   )

    self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, expected_seq_len, expected_dim)   )






  def 	_UpperCAmelCase				(				self:			Dict				,				__lowerCAmelCase:			Optional[int]				,				__lowerCAmelCase:			Optional[Any]				,				__lowerCAmelCase:			int   ) -> Optional[Any]:




    '''simple docstring'''




    __UpperCAmelCase						    =       MaskFormerSwinBackbone(config=__lowerCAmelCase   )
    model.to(__lowerCAmelCase   )
    model.eval()
    __UpperCAmelCase						    =       model(__lowerCAmelCase   )

    # verify feature maps
    self.parent.assertEqual(len(result.feature_maps   )				,				len(config.out_features   )   )
    self.parent.assertListEqual(list(result.feature_maps[0].shape   )				,				[13, 16, 16, 16]   )

    # verify channels
    self.parent.assertEqual(len(model.channels   )				,				len(config.out_features   )   )
    self.parent.assertListEqual(model.channels				,				[16, 32, 64]   )

    # verify ValueError
    with self.parent.assertRaises(__lowerCAmelCase   ):
      __UpperCAmelCase						    =       ["stem"]
      __UpperCAmelCase						    =       MaskFormerSwinBackbone(config=__lowerCAmelCase   )






  def 	_UpperCAmelCase				(				self:			Optional[Any]   ) -> Dict:




    '''simple docstring'''




    __UpperCAmelCase						    =       self.prepare_config_and_inputs()
    __UpperCAmelCase    ,		__UpperCAmelCase    ,		__UpperCAmelCase						    =       config_and_inputs
    __UpperCAmelCase						    =       {"pixel_values": pixel_values}
    return config, inputs_dict






@require_torch
class 			UpperCAmelCase__    (		snake_case		,	snake_case		,	unittest.TestCase					):



  """simple docstring"""






  lowerCAmelCase__		:	Any    		= (
      (
          MaskFormerSwinModel,
          MaskFormerSwinBackbone,
      )
      if is_torch_available()
      else ()
  )
  lowerCAmelCase__		:	Tuple    		= {'feature-extraction': MaskFormerSwinModel} if is_torch_available() else {}
  lowerCAmelCase__		:	Union[str, Any]    		= False
  lowerCAmelCase__		:	List[Any]    		= False
  lowerCAmelCase__		:	Union[str, Any]    		= False
  lowerCAmelCase__		:	Optional[int]    		= False
  lowerCAmelCase__		:	List[Any]    		= False






  def 	_UpperCAmelCase				(				self:			Tuple   ) -> Optional[int]:




    '''simple docstring'''




    __UpperCAmelCase						    =       MaskFormerSwinModelTester(self   )
    __UpperCAmelCase						    =       ConfigTester(self				,				config_class=__lowerCAmelCase				,				embed_dim=37   )






  @require_torch_multi_gpu
  @unittest.skip(
      reason=(
          "`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"
          " `nn.DataParallel`"
      )   )
  def 	_UpperCAmelCase				(				self:			str   ) -> int:




    '''simple docstring'''




    pass






  def 	_UpperCAmelCase				(				self:			Any   ) -> Union[str, Any]:




    '''simple docstring'''




    self.create_and_test_config_common_properties()
    self.config_tester.create_and_test_config_to_json_string()
    self.config_tester.create_and_test_config_to_json_file()
    self.config_tester.create_and_test_config_from_and_save_pretrained()
    self.config_tester.create_and_test_config_with_num_labels()
    self.config_tester.check_config_can_be_init_without_params()
    self.config_tester.check_config_arguments_init()






  def 	_UpperCAmelCase				(				self:			str   ) -> int:




    '''simple docstring'''




    return






  def 	_UpperCAmelCase				(				self:			Union[str, Any]   ) -> List[str]:




    '''simple docstring'''




    __UpperCAmelCase						    =       self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*__lowerCAmelCase   )






  def 	_UpperCAmelCase				(				self:			Optional[Any]   ) -> Optional[int]:




    '''simple docstring'''




    __UpperCAmelCase						    =       self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_backbone(*__lowerCAmelCase   )






  @unittest.skip("Swin does not use inputs_embeds"   )
  def 	_UpperCAmelCase				(				self:			Any   ) -> Tuple:




    '''simple docstring'''




    pass






  @unittest.skip("Swin does not support feedforward chunking"   )
  def 	_UpperCAmelCase				(				self:			str   ) -> Tuple:




    '''simple docstring'''




    pass






  def 	_UpperCAmelCase				(				self:			Any   ) -> str:




    '''simple docstring'''




    __UpperCAmelCase    ,		__UpperCAmelCase						    =       self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
      __UpperCAmelCase						    =       model_class(__lowerCAmelCase   )
      self.assertIsInstance(model.get_input_embeddings()				,				(nn.Module)   )
      __UpperCAmelCase						    =       model.get_output_embeddings()
      self.assertTrue(x is None or isinstance(__lowerCAmelCase				,				nn.Linear   )   )






  def 	_UpperCAmelCase				(				self:			Any   ) -> str:




    '''simple docstring'''




    __UpperCAmelCase    ,		__UpperCAmelCase						    =       self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
      __UpperCAmelCase						    =       model_class(__lowerCAmelCase   )
      __UpperCAmelCase						    =       inspect.signature(model.forward   )
      # signature.parameters is an OrderedDict => so arg_names order is deterministic
      __UpperCAmelCase						    =       [*signature.parameters.keys()]

      __UpperCAmelCase						    =       ["pixel_values"]
      self.assertListEqual(arg_names[:1]				,				__lowerCAmelCase   )






  @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions"   )
  def 	_UpperCAmelCase				(				self:			Optional[int]   ) -> int:




    '''simple docstring'''




    pass






  @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone"   )
  def 	_UpperCAmelCase				(				self:			str   ) -> Dict:




    '''simple docstring'''




    pass






  def 	_UpperCAmelCase				(				self:			Optional[int]				,				__lowerCAmelCase:			Tuple				,				__lowerCAmelCase:			Dict				,				__lowerCAmelCase:			List[Any]				,				__lowerCAmelCase:			Any   ) -> Dict:




    '''simple docstring'''




    __UpperCAmelCase						    =       model_class(__lowerCAmelCase   )
    model.to(__lowerCAmelCase   )
    model.eval()

    with torch.no_grad():
      __UpperCAmelCase						    =       model(**self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase   )   )

    __UpperCAmelCase						    =       outputs.hidden_states

    __UpperCAmelCase						    =       getattr(
        self.model_tester				,				"expected_num_hidden_layers"				,				len(self.model_tester.depths   ) + 1   )
    self.assertEqual(len(__lowerCAmelCase   )				,				__lowerCAmelCase   )

    # Swin has a different seq_length
    __UpperCAmelCase						    =       (
        config.patch_size
        if isinstance(config.patch_size				,				collections.abc.Iterable   )
        else (config.patch_size, config.patch_size)
    )

    __UpperCAmelCase						    =       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

    self.assertListEqual(
        list(hidden_states[0].shape[-2:]   )				,				[num_patches, self.model_tester.embed_dim]				,				)






  def 	_UpperCAmelCase				(				self:			Optional[Any]   ) -> Dict:




    '''simple docstring'''




    __UpperCAmelCase    ,		__UpperCAmelCase						    =       self.model_tester.prepare_config_and_inputs_for_common()

    __UpperCAmelCase						    =       (
        self.model_tester.image_size
        if isinstance(self.model_tester.image_size				,				collections.abc.Iterable   )
        else (self.model_tester.image_size, self.model_tester.image_size)
    )

    for model_class in self.all_model_classes:
      __UpperCAmelCase						    =       True
      self.check_hidden_states_output(__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase   )

      # check that output_hidden_states also work using config
      del inputs_dict["output_hidden_states"]
      __UpperCAmelCase						    =       True

      self.check_hidden_states_output(__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase   )






  def 	_UpperCAmelCase				(				self:			Optional[int]   ) -> Any:




    '''simple docstring'''




    __UpperCAmelCase    ,		__UpperCAmelCase						    =       self.model_tester.prepare_config_and_inputs_for_common()
    __UpperCAmelCase						    =       3

    __UpperCAmelCase						    =       (
        self.model_tester.image_size
        if isinstance(self.model_tester.image_size				,				collections.abc.Iterable   )
        else (self.model_tester.image_size, self.model_tester.image_size)
    )
    __UpperCAmelCase						    =       (
        config.patch_size
        if isinstance(config.patch_size				,				collections.abc.Iterable   )
        else (config.patch_size, config.patch_size)
    )

    __UpperCAmelCase						    =       image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
    __UpperCAmelCase						    =       image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

    for model_class in self.all_model_classes:
      __UpperCAmelCase						    =       True
      self.check_hidden_states_output(__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase				,				(padded_height, padded_width)   )

      # check that output_hidden_states also work using config
      del inputs_dict["output_hidden_states"]
      __UpperCAmelCase						    =       True
      self.check_hidden_states_output(__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase				,				(padded_height, padded_width)   )






  @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints"   )
  def 	_UpperCAmelCase				(				self:			Optional[Any]   ) -> Optional[int]:




    '''simple docstring'''




    pass






  @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"   )
  def 	_UpperCAmelCase				(				self:			List[Any]   ) -> List[str]:




    '''simple docstring'''




    pass






  @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"   )
  def 	_UpperCAmelCase				(				self:			str   ) -> List[str]:




    '''simple docstring'''




    pass






  def 	_UpperCAmelCase				(				self:			Optional[int]   ) -> Tuple:




    '''simple docstring'''




    __UpperCAmelCase    ,		__UpperCAmelCase						    =       self.model_tester.prepare_config_and_inputs_for_common()

    def set_nan_tensor_to_zero(__lowerCAmelCase:			Optional[Any]   ):
      __UpperCAmelCase						    =       0
      return t

    def check_equivalence(__lowerCAmelCase:			str				,				__lowerCAmelCase:			str				,				__lowerCAmelCase:			int				,				__lowerCAmelCase:			int={}   ):
      with torch.no_grad():
        __UpperCAmelCase						    =       model(**__lowerCAmelCase				,				return_dict=__lowerCAmelCase				,				**__lowerCAmelCase   )
        __UpperCAmelCase						    =       model(**__lowerCAmelCase				,				return_dict=__lowerCAmelCase				,				**__lowerCAmelCase   ).to_tuple()

        def recursive_check(__lowerCAmelCase:			int				,				__lowerCAmelCase:			List[Any]   ):
          if isinstance(__lowerCAmelCase				,				(List, Tuple)   ):
            for tuple_iterable_value, dict_iterable_value in zip(__lowerCAmelCase				,				__lowerCAmelCase   ):
              recursive_check(__lowerCAmelCase				,				__lowerCAmelCase   )
          elif isinstance(__lowerCAmelCase				,				__lowerCAmelCase   ):
            for tuple_iterable_value, dict_iterable_value in zip(
                tuple_object.values()				,				dict_object.values()   ):
              recursive_check(__lowerCAmelCase				,				__lowerCAmelCase   )
          elif tuple_object is None:
            return
          else:
            self.assertTrue(
                torch.allclose(
                    set_nan_tensor_to_zero(__lowerCAmelCase   )				,				set_nan_tensor_to_zero(__lowerCAmelCase   )				,				atol=1E-5   )				,				msg=(
                    "Tuple and dict output are not equal. Difference:"
                    F''' {torch.max(torch.abs(tuple_object - dict_object   )   )}. Tuple has `nan`:'''
                    F''' {torch.isnan(__lowerCAmelCase   ).any()} and `inf`: {torch.isinf(__lowerCAmelCase   )}. Dict has'''
                    F''' `nan`: {torch.isnan(__lowerCAmelCase   ).any()} and `inf`: {torch.isinf(__lowerCAmelCase   )}.'''
                )				,				)

        recursive_check(__lowerCAmelCase				,				__lowerCAmelCase   )

    for model_class in self.all_model_classes:
      __UpperCAmelCase						    =       model_class(__lowerCAmelCase   )
      model.to(__lowerCAmelCase   )
      model.eval()

      __UpperCAmelCase						    =       self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase   )
      __UpperCAmelCase						    =       self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase   )
      check_equivalence(__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase   )

      __UpperCAmelCase						    =       self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase				,				return_labels=__lowerCAmelCase   )
      __UpperCAmelCase						    =       self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase				,				return_labels=__lowerCAmelCase   )
      check_equivalence(__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase   )

      __UpperCAmelCase						    =       self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase   )
      __UpperCAmelCase						    =       self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase   )
      check_equivalence(__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase				,				{"output_hidden_states": True}   )

      __UpperCAmelCase						    =       self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase				,				return_labels=__lowerCAmelCase   )
      __UpperCAmelCase						    =       self._prepare_for_class(__lowerCAmelCase				,				__lowerCAmelCase				,				return_labels=__lowerCAmelCase   )
      check_equivalence(__lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase				,				{"output_hidden_states": True}   )






@require_torch
class 			UpperCAmelCase__    (		unittest.TestCase		,	snake_case					):



  """simple docstring"""






  lowerCAmelCase__		:	Optional[Any]    		= (MaskFormerSwinBackbone,) if is_torch_available() else ()
  lowerCAmelCase__		:	List[Any]    		= MaskFormerSwinConfig






  def 	_UpperCAmelCase				(				self:			Optional[Any]   ) -> List[str]:




    '''simple docstring'''




    __UpperCAmelCase						    =       MaskFormerSwinModelTester(self   )






  def 	_UpperCAmelCase				(				self:			Union[str, Any]   ) -> Tuple:




    '''simple docstring'''




    __UpperCAmelCase    ,		__UpperCAmelCase						    =       self.model_tester.prepare_config_and_inputs_for_common()
    __UpperCAmelCase						    =       inputs_dict["pixel_values"].shape[0]

    for backbone_class in self.all_model_classes:
      __UpperCAmelCase						    =       backbone_class(__lowerCAmelCase   )
      backbone.to(__lowerCAmelCase   )
      backbone.eval()

      __UpperCAmelCase						    =       backbone(**__lowerCAmelCase   )

      # Test default outputs and verify feature maps
      self.assertIsInstance(outputs.feature_maps				,				__lowerCAmelCase   )
      self.assertTrue(len(outputs.feature_maps   ) == len(backbone.channels   )   )
      for feature_map, n_channels in zip(outputs.feature_maps				,				backbone.channels   ):
        self.assertTrue(feature_map.shape[:2]				,				(batch_size, n_channels)   )
      self.assertIsNone(outputs.hidden_states   )
      self.assertIsNone(outputs.attentions   )

      # Test output_hidden_states=True
      __UpperCAmelCase						    =       backbone(**__lowerCAmelCase				,				output_hidden_states=__lowerCAmelCase   )
      self.assertIsNotNone(outputs.hidden_states   )
      self.assertTrue(len(outputs.hidden_states   )				,				len(backbone.stage_names   )   )
      # We skip the stem layer
      for hidden_states, n_channels in zip(outputs.hidden_states[1:]				,				backbone.channels   ):
        for hidden_state in hidden_states:
          # Hidden states are in the format (batch_size, (height * width), n_channels)
          __UpperCAmelCase    ,		__UpperCAmelCase    ,		__UpperCAmelCase						    =       hidden_state.shape
          self.assertTrue((h_batch_size, h_n_channels)				,				(batch_size, n_channels)   )

            # Test output_attentions=True
      if self.has_attentions:
        __UpperCAmelCase						    =       backbone(**__lowerCAmelCase				,				output_attentions=__lowerCAmelCase   )
        self.assertIsNotNone(outputs.attentions   )




import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class 			UpperCAmelCase__    (		snake_case					):



  """simple docstring"""






  lowerCAmelCase__		:	Optional[int]    		= ['image_processor', 'tokenizer']
  lowerCAmelCase__		:	Any    		= 'CLIPImageProcessor'
  lowerCAmelCase__		:	Any    		= ('CLIPTokenizer', 'CLIPTokenizerFast')






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




    '''simple docstring'''




    __UpperCAmelCase						    =       None
    if "feature_extractor" in kwargs:
      warnings.warn(
          "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
          " instead."				,				__lowerCAmelCase				,				)
      __UpperCAmelCase						    =       kwargs.pop("feature_extractor"   )

    __UpperCAmelCase						    =       image_processor if image_processor is not None else feature_extractor
    if image_processor is None:
      raise ValueError("You need to specify an `image_processor`."   )
    if tokenizer is None:
      raise ValueError("You need to specify a `tokenizer`."   )

    super().__init__(__lowerCAmelCase				,				__lowerCAmelCase   )






  def __call__(				self:			Optional[int]				,				__lowerCAmelCase:			Union[str, Any]=None				,				__lowerCAmelCase:			Dict=None				,				__lowerCAmelCase:			Optional[int]=None				,				**__lowerCAmelCase:			Optional[int]   ) -> Dict:




    '''simple docstring'''




    if text is None and images is None:
      raise ValueError("You have to specify either text or images. Both cannot be none."   )

    if text is not None:
      __UpperCAmelCase						    =       self.tokenizer(__lowerCAmelCase				,				return_tensors=__lowerCAmelCase				,				**__lowerCAmelCase   )

    if images is not None:
      __UpperCAmelCase						    =       self.image_processor(__lowerCAmelCase				,				return_tensors=__lowerCAmelCase				,				**__lowerCAmelCase   )

    if text is not None and images is not None:
      __UpperCAmelCase						    =       image_features.pixel_values
      return encoding
    elif text is not None:
      return encoding
    else:
      return BatchEncoding(data=dict(**__lowerCAmelCase   )				,				tensor_type=__lowerCAmelCase   )






  def 	_UpperCAmelCase				(				self:			str				,				*__lowerCAmelCase:			str				,				**__lowerCAmelCase:			List[Any]   ) -> Optional[Any]:




    '''simple docstring'''




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






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




    '''simple docstring'''




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






  @property
  def 	_UpperCAmelCase				(				self:			Tuple   ) -> List[Any]:




    '''simple docstring'''




    __UpperCAmelCase						    =       self.tokenizer.model_input_names
    __UpperCAmelCase						    =       self.image_processor.model_input_names
    return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names   )   )






  @property
  def 	_UpperCAmelCase				(				self:			Optional[int]   ) -> str:




    '''simple docstring'''




    warnings.warn(
        "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."				,				__lowerCAmelCase				,				)
    return self.image_processor_class






  @property
  def 	_UpperCAmelCase				(				self:			List[Any]   ) -> List[str]:




    '''simple docstring'''




    warnings.warn(
        "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."				,				__lowerCAmelCase				,				)
    return self.image_processor



