
"""simple docstring"""




import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
							from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
							from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
							from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


lowerCamelCase_  :	Tuple 				=					DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

lowerCamelCase_  :	Optional[Any] 				=					"""main"""
# Default branch name
lowerCamelCase_  :	Dict 				=					"""f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"""
# One particular commit (not the top of `main`)
lowerCamelCase_  :	Any 				=					"""aaaaaaa"""
# This commit does not exist, so we should 404.

lowerCamelCase_  :	List[Any] 				=					"""d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"""
# Sha-1 of config.json on the top of `main`, for checking purposes
lowerCamelCase_  :	Any 				=					"""4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"""







@contextlib.contextmanager
def     A__   (  )					->		Optional[int]:
				print("""Welcome!"""  )
				yield
				print("""Bye!"""  )







@contextlib.contextmanager
def     A__   (  )					->		Dict:
				print("""Bonjour!"""  )
				yield
				print("""Au revoir!"""  )

class     _UpperCamelCase			(   unittest.TestCase					):






			'''simple docstring'''

			def  lowerCAmelCase__		(    self	:    Union[str, Any] ):
							# If the spec is missing, importlib would not be able to import the module dynamically.
							assert transformers.__spec__ is not None
							assert importlib.util.find_spec("""transformers""" ) is not None




class     _UpperCamelCase			(   unittest.TestCase					):






			'''simple docstring'''

			@unittest.mock.patch("""sys.stdout"""  ,		new_callable=io.StringIO )
			def  lowerCAmelCase__		(    self	:    Optional[Any]  ,		snake_case_	:    Optional[Any] ):
							with ContextManagers([] ):
											print("""Transformers are awesome!""" )
							# The print statement adds a new line at the end of the output
							self.assertEqual(mock_stdout.getvalue()  ,		"""Transformers are awesome!\n""" )

			@unittest.mock.patch("""sys.stdout"""  ,		new_callable=io.StringIO )
			def  lowerCAmelCase__		(    self	:    Any  ,		snake_case_	:    Tuple ):
							with ContextManagers([context_en()] ):
											print("""Transformers are awesome!""" )
							# The output should be wrapped with an English welcome and goodbye
							self.assertEqual(mock_stdout.getvalue()  ,		"""Welcome!\nTransformers are awesome!\nBye!\n""" )

			@unittest.mock.patch("""sys.stdout"""  ,		new_callable=io.StringIO )
			def  lowerCAmelCase__		(    self	:    Optional[int]  ,		snake_case_	:    Optional[int] ):
							with ContextManagers([context_fr(), context_en()] ):
											print("""Transformers are awesome!""" )
							# The output should be wrapped with an English and French welcome and goodbye
							self.assertEqual(mock_stdout.getvalue()  ,		"""Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n""" )

			@require_torch
			def  lowerCAmelCase__		(    self	:    int ):
							self.assertEqual(find_labels(snake_case_ )  ,		["""labels"""] )
							self.assertEqual(find_labels(snake_case_ )  ,		["""labels""", """next_sentence_label"""] )
							self.assertEqual(find_labels(snake_case_ )  ,		["""start_positions""", """end_positions"""] )

							class     _UpperCamelCase			(   _A					):






										'''simple docstring'''

										pass




							self.assertEqual(find_labels(snake_case_ )  ,		["""labels"""] )

			@require_tf
			def  lowerCAmelCase__		(    self	:    str ):
							self.assertEqual(find_labels(snake_case_ )  ,		["""labels"""] )
							self.assertEqual(find_labels(snake_case_ )  ,		["""labels""", """next_sentence_label"""] )
							self.assertEqual(find_labels(snake_case_ )  ,		["""start_positions""", """end_positions"""] )

							class     _UpperCamelCase			(   _A					):






										'''simple docstring'''

										pass




							self.assertEqual(find_labels(snake_case_ )  ,		["""labels"""] )




			@require_flax
			def  lowerCAmelCase__		(    self	:    Optional[int] ):
							# Flax models don't have labels
							self.assertEqual(find_labels(snake_case_ )  ,		[] )
							self.assertEqual(find_labels(snake_case_ )  ,		[] )
							self.assertEqual(find_labels(snake_case_ )  ,		[] )

							class     _UpperCamelCase			(   _A					):






										'''simple docstring'''

										pass




							self.assertEqual(find_labels(snake_case_ )  ,		[] )








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

class     _UpperCamelCase			(   _A					):






			'''simple docstring'''

			__UpperCamelCase :  Union[str, Any]    =	["""image_processor""", """tokenizer"""]
			__UpperCamelCase :  List[Any]    =	"""AutoImageProcessor"""
			__UpperCamelCase :  Tuple    =	"""AutoTokenizer"""

			def __init__(    self	:    Any  ,		snake_case_	:    Optional[Any]  ,		snake_case_	:    Any ):
							super().__init__(snake_case_  ,		snake_case_ )
							UpperCamelCase_:							int		=  self.image_processor

			def __call__(    self	:    str  ,		snake_case_	:    Optional[int]=None  ,		snake_case_	:    int=None  ,		snake_case_	:    Dict=None  ,		**snake_case_	:    Optional[int] ):

							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_:							List[Any]		=  self.tokenizer(snake_case_  ,		return_tensors=snake_case_  ,		**snake_case_ )

							if images is not None:
											UpperCamelCase_:							Any		=  self.image_processor(snake_case_  ,		return_tensors=snake_case_  ,		**snake_case_ )

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

			def  lowerCAmelCase__		(    self	:    List[str]  ,		*snake_case_	:    int  ,		**snake_case_	:    Optional[Any] ):
							return self.tokenizer.batch_decode(*snake_case_  ,		**snake_case_ )

			def  lowerCAmelCase__		(    self	:    int  ,		*snake_case_	:    Optional[Any]  ,		**snake_case_	:    str ):
							return self.tokenizer.decode(*snake_case_  ,		**snake_case_ )




			@property
			def  lowerCAmelCase__		(    self	:    Union[str, Any] ):
							return ["input_ids", "attention_mask", "pixel_values"]






