

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase_	     =     {
    '''configuration_big_bird''': ['''BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BigBirdConfig''', '''BigBirdOnnxConfig'''],
}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCAmelCase_	     =     ['''BigBirdTokenizer''']

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCAmelCase_	     =     ['''BigBirdTokenizerFast''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCAmelCase_	     =     [
					    '''BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''BigBirdForCausalLM''',
					    '''BigBirdForMaskedLM''',
					    '''BigBirdForMultipleChoice''',
					    '''BigBirdForPreTraining''',
					    '''BigBirdForQuestionAnswering''',
					    '''BigBirdForSequenceClassification''',
					    '''BigBirdForTokenClassification''',
					    '''BigBirdLayer''',
					    '''BigBirdModel''',
					    '''BigBirdPreTrainedModel''',
					    '''load_tf_weights_in_big_bird''',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCAmelCase_	     =     [
					    '''FlaxBigBirdForCausalLM''',
					    '''FlaxBigBirdForMaskedLM''',
					    '''FlaxBigBirdForMultipleChoice''',
					    '''FlaxBigBirdForPreTraining''',
					    '''FlaxBigBirdForQuestionAnswering''',
					    '''FlaxBigBirdForSequenceClassification''',
					    '''FlaxBigBirdForTokenClassification''',
					    '''FlaxBigBirdModel''',
					    '''FlaxBigBirdPreTrainedModel''',
					]

if TYPE_CHECKING:
					from .configuration_big_bird import BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP, BigBirdConfig, BigBirdOnnxConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_big_bird import BigBirdTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_big_bird_fast import BigBirdTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_big_bird import (
										    BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST,
										    BigBirdForCausalLM,
										    BigBirdForMaskedLM,
										    BigBirdForMultipleChoice,
										    BigBirdForPreTraining,
										    BigBirdForQuestionAnswering,
										    BigBirdForSequenceClassification,
										    BigBirdForTokenClassification,
										    BigBirdLayer,
										    BigBirdModel,
										    BigBirdPreTrainedModel,
										    load_tf_weights_in_big_bird,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_big_bird import (
										    FlaxBigBirdForCausalLM,
										    FlaxBigBirdForMaskedLM,
										    FlaxBigBirdForMultipleChoice,
										    FlaxBigBirdForPreTraining,
										    FlaxBigBirdForQuestionAnswering,
										    FlaxBigBirdForSequenceClassification,
										    FlaxBigBirdForTokenClassification,
										    FlaxBigBirdModel,
										    FlaxBigBirdPreTrainedModel,
										)

else:
					import sys

					lowerCAmelCase_	     =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin





class      snake_case_       (		__A ):







			'''simple docstring'''

			SCREAMING_SNAKE_CASE					:       List[str]						      =    ["image_processor", "tokenizer"]
			SCREAMING_SNAKE_CASE					:       List[Any]						      =    "AutoImageProcessor"
			SCREAMING_SNAKE_CASE					:       Optional[int]						      =    "AutoTokenizer"







			def __init__(					self			:    List[str]							,       _UpperCamelCase			:    List[str]=None							,       _UpperCamelCase			:    Any=None							,       **_UpperCamelCase			:    Tuple							)				->str:
									snake_case_       =     None
									if "feature_extractor" in kwargs:
															warnings.warn(
															    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
															    ''' instead.'''							,       _UpperCamelCase							,       )
															snake_case_       =     kwargs.pop('''feature_extractor'''							)

									snake_case_       =     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__(_UpperCamelCase							,       _UpperCamelCase							)
									snake_case_       =     self.image_processor
									snake_case_       =     False







			def __call__(					self			:    int							,       *_UpperCamelCase			:    Tuple							,       **_UpperCamelCase			:    Any							)				->Tuple:
									# For backward compatibility
									if self._in_target_context_manager:
															return self.current_processor(*_UpperCamelCase							,       **_UpperCamelCase							)

									snake_case_       =     kwargs.pop('''images'''							,       _UpperCamelCase							)
									snake_case_       =     kwargs.pop('''text'''							,       _UpperCamelCase							)
									if len(_UpperCamelCase							) > 0:
															snake_case_       =     args[0]
															snake_case_       =     args[1:]

									if images is None and text is None:
															raise ValueError('''You need to specify either an `images` or `text` input to process.'''							)

									if images is not None:
															snake_case_       =     self.image_processor(_UpperCamelCase							,       *_UpperCamelCase							,       **_UpperCamelCase							)
									if text is not None:
															snake_case_       =     self.tokenizer(_UpperCamelCase							,       **_UpperCamelCase							)

									if text is None:
															return inputs
									elif images is None:
															return encodings
									else:
															snake_case_       =     encodings['''input_ids''']
															return inputs







			def     snake_case__(					self			:    List[Any]							,       *_UpperCamelCase			:    Union[str, Any]							,       **_UpperCamelCase			:    Tuple							)				->Any:
									return self.tokenizer.batch_decode(*_UpperCamelCase							,       **_UpperCamelCase							)







			def     snake_case__(					self			:    Optional[Any]							,       *_UpperCamelCase			:    List[Any]							,       **_UpperCamelCase			:    Union[str, Any]							)				->List[str]:
									return self.tokenizer.decode(*_UpperCamelCase							,       **_UpperCamelCase							)







			@contextmanager
			def     snake_case__(					self			:    Any							)				->Any:
									warnings.warn(
									    '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '''
									    '''labels by using the argument `text` of the regular `__call__` method (either in the same call as '''
									    '''your images inputs, or in a separate call.'''							)
									snake_case_       =     True
									snake_case_       =     self.tokenizer
									yield
									snake_case_       =     self.image_processor
									snake_case_       =     False







			@property
			def     snake_case__(					self			:    Optional[int]							)				->int:
									warnings.warn(
									    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''							,       _UpperCamelCase							,       )
									return self.image_processor_class







			@property
			def     snake_case__(					self			:    Union[str, Any]							)				->List[Any]:
									warnings.warn(
									    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''							,       _UpperCamelCase							,       )
									return self.image_processor