

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


A_			:					Optional[int]    			=     DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

A_			:					List[Any]    			=     'main'
# Default branch name
A_			:					Any    			=     'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
A_			:					List[str]    			=     'aaaaaaa'
# This commit does not exist, so we should 404.

A_			:					Tuple    			=     'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
A_			:					Union[str, Any]    			=     '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'

@contextlib.contextmanager
def 		UpperCamelCase   ()	-> Union[str, Any]:
	print("""Welcome!"""   )
	yield
	print("""Bye!"""   )

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



class        _a		(unittest.TestCase							):


					'''simple docstring'''






					def     __A     (					self     ):
						# 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        _a		(unittest.TestCase							):


					'''simple docstring'''






					@unittest.mock.patch("""sys.stdout"""       ,			new_callable=io.StringIO     )
					def     __A     (					self       ,			A__     ):
						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     __A     (					self       ,			A__     ):
						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     __A     (					self       ,			A__     ):
						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     __A     (					self     ):
						self.assertEqual(find_labels(A__     )       ,			["""labels"""]     )
						self.assertEqual(find_labels(A__     )       ,			["""labels""", """next_sentence_label"""]     )
						self.assertEqual(find_labels(A__     )       ,			["""start_positions""", """end_positions"""]     )



						class        _a		(__magic_name__							):


											'''simple docstring'''






											pass



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






					@require_tf
					def     __A     (					self     ):
						self.assertEqual(find_labels(A__     )       ,			["""labels"""]     )
						self.assertEqual(find_labels(A__     )       ,			["""labels""", """next_sentence_label"""]     )
						self.assertEqual(find_labels(A__     )       ,			["""start_positions""", """end_positions"""]     )



						class        _a		(__magic_name__							):


											'''simple docstring'''






											pass



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






					@require_flax
					def     __A     (					self     ):
						# Flax models don't have labels
						self.assertEqual(find_labels(A__     )       ,			[]     )
						self.assertEqual(find_labels(A__     )       ,			[]     )
						self.assertEqual(find_labels(A__     )       ,			[]     )



						class        _a		(__magic_name__							):


											'''simple docstring'''






											pass



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






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


A_			:					Tuple    			=     {
    'configuration_xlm': ['XLM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'XLMConfig', 'XLMOnnxConfig'],
    'tokenization_xlm': ['XLMTokenizer'],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A_			:					Dict    			=     [
	    'XLM_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'XLMForMultipleChoice',
	    'XLMForQuestionAnswering',
	    'XLMForQuestionAnsweringSimple',
	    'XLMForSequenceClassification',
	    'XLMForTokenClassification',
	    'XLMModel',
	    'XLMPreTrainedModel',
	    'XLMWithLMHeadModel',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A_			:					str    			=     [
	    'TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'TFXLMForMultipleChoice',
	    'TFXLMForQuestionAnsweringSimple',
	    'TFXLMForSequenceClassification',
	    'TFXLMForTokenClassification',
	    'TFXLMMainLayer',
	    'TFXLMModel',
	    'TFXLMPreTrainedModel',
	    'TFXLMWithLMHeadModel',
	]


if TYPE_CHECKING:
	from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
	from .tokenization_xlm import XLMTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_xlm import (
		    XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    XLMForMultipleChoice,
		    XLMForQuestionAnswering,
		    XLMForQuestionAnsweringSimple,
		    XLMForSequenceClassification,
		    XLMForTokenClassification,
		    XLMModel,
		    XLMPreTrainedModel,
		    XLMWithLMHeadModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_xlm import (
		    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFXLMForMultipleChoice,
		    TFXLMForQuestionAnsweringSimple,
		    TFXLMForSequenceClassification,
		    TFXLMForTokenClassification,
		    TFXLMMainLayer,
		    TFXLMModel,
		    TFXLMPreTrainedModel,
		    TFXLMWithLMHeadModel,
		)

else:
	import sys

	A_			:					Tuple    			=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



