






import warnings
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    (     _lowerCAmelCase   ):
	__snake_case	:int   =       ["""image_processor""", """tokenizer"""]
	__snake_case	:str   =       """ViltImageProcessor"""
	__snake_case	:List[str]   =       ("""BertTokenizer""", """BertTokenizerFast""")







	def __init__(  self      :							List[Any]       ,				_lowerCAmelCase      :							Tuple=None       ,				_lowerCAmelCase      :							str=None       ,				**_lowerCAmelCase      :							Any			)		-> Dict:
		"""simple docstring"""







		__lowercase             =  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       ,				)
			__lowercase             =  kwargs.pop("""feature_extractor"""			)

		__lowercase             =  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			)
		__lowercase             =  self.image_processor







	def __call__(  self      :							Tuple       ,				_lowerCAmelCase      :							Union[str, Any]       ,				_lowerCAmelCase      :							Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None       ,				_lowerCAmelCase      :							bool = True       ,				_lowerCAmelCase      :							Union[bool, str, PaddingStrategy] = False       ,				_lowerCAmelCase      :							Union[bool, str, TruncationStrategy] = None       ,				_lowerCAmelCase      :							Optional[int] = None       ,				_lowerCAmelCase      :							int = 0       ,				_lowerCAmelCase      :							Optional[int] = None       ,				_lowerCAmelCase      :							Optional[bool] = None       ,				_lowerCAmelCase      :							Optional[bool] = None       ,				_lowerCAmelCase      :							bool = False       ,				_lowerCAmelCase      :							bool = False       ,				_lowerCAmelCase      :							bool = False       ,				_lowerCAmelCase      :							bool = False       ,				_lowerCAmelCase      :							bool = True       ,				_lowerCAmelCase      :							Optional[Union[str, TensorType]] = None       ,				**_lowerCAmelCase      :							int       ,				)		-> BatchEncoding:
		"""simple docstring"""







		__lowercase             =  self.tokenizer(
		    text=_lowerCAmelCase       ,				add_special_tokens=_lowerCAmelCase       ,				padding=_lowerCAmelCase       ,				truncation=_lowerCAmelCase       ,				max_length=_lowerCAmelCase       ,				stride=_lowerCAmelCase       ,				pad_to_multiple_of=_lowerCAmelCase       ,				return_token_type_ids=_lowerCAmelCase       ,				return_attention_mask=_lowerCAmelCase       ,				return_overflowing_tokens=_lowerCAmelCase       ,				return_special_tokens_mask=_lowerCAmelCase       ,				return_offsets_mapping=_lowerCAmelCase       ,				return_length=_lowerCAmelCase       ,				verbose=_lowerCAmelCase       ,				return_tensors=_lowerCAmelCase       ,				**_lowerCAmelCase       ,				)
		# add pixel_values + pixel_mask
		__lowercase             =  self.image_processor(_lowerCAmelCase       ,				return_tensors=_lowerCAmelCase			)
		encoding.update(_lowerCAmelCase			)

		return encoding







	def  _a   (  self      :							str       ,				*_lowerCAmelCase      :							Dict       ,				**_lowerCAmelCase      :							Optional[Any]			)		-> List[str]:
		"""simple docstring"""







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







	def  _a   (  self      :							Union[str, Any]       ,				*_lowerCAmelCase      :							Optional[Any]       ,				**_lowerCAmelCase      :							int			)		-> str:
		"""simple docstring"""







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







	@property
	def  _a   (  self      :							Optional[int]			)		-> Dict:
		"""simple docstring"""







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







	@property
	def  _a   (  self      :							Dict			)		-> Optional[Any]:
		"""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  _a   (  self      :							Dict			)		-> List[Any]:
		"""simple docstring"""







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









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__UpperCamelCase      :      Tuple     						=						{
    """configuration_swiftformer""": [
        """SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """SwiftFormerConfig""",
        """SwiftFormerOnnxConfig""",
    ]
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__UpperCamelCase      :      Optional[Any]     						=						[
						    """SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """SwiftFormerForImageClassification""",
						    """SwiftFormerModel""",
						    """SwiftFormerPreTrainedModel""",
						]

if TYPE_CHECKING:
						from .configuration_swiftformer import (
						    SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    SwiftFormerConfig,
						    SwiftFormerOnnxConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_swiftformer import (
												    SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    SwiftFormerForImageClassification,
												    SwiftFormerModel,
												    SwiftFormerPreTrainedModel,
												)

else:
						import sys

						__UpperCamelCase      :      List[Any]     						=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

