

'''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


a_						     =    DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

a_						     =    'main'
# Default branch name
a_						     =    'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
a_						     =    'aaaaaaa'
# This commit does not exist, so we should 404.

a_						     =    'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
a_						     =    '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'

@contextlib.contextmanager
def  lowerCamelCase__ (					):
	print("Welcome!")
	yield
	print("Bye!")

@contextlib.contextmanager
def  lowerCamelCase__ (					):
	print("Bonjour!")
	yield
	print("Au revoir!")






class _UpperCamelCase							(							unittest.TestCase   ):
			'''simple docstring'''







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

				"""simple docstring"""

				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 							__UpperCamelCase (			self							: Any      ,      a							: Any	)							->       Optional[Any]:

				"""simple docstring"""

				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 							__UpperCamelCase (			self							: str      ,      a							: List[str]	)							->       List[Any]:

				"""simple docstring"""

				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 							__UpperCamelCase (			self							: int      ,      a							: List[Any]	)							->       int:

				"""simple docstring"""

				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 							__UpperCamelCase (			self							: List[str]	)							->       List[str]:

				"""simple docstring"""

				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 _UpperCamelCase							(							__A   ):
							'''simple docstring'''







							pass

				self.assertEqual(find_labels(a	)      ,      ["labels"]	)
			@require_tf
			def 							__UpperCamelCase (			self							: Dict	)							->       Any:

				"""simple docstring"""

				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 _UpperCamelCase							(							__A   ):
							'''simple docstring'''







							pass

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






			@require_flax
			def 							__UpperCamelCase (			self							: List[str]	)							->       Tuple:

				"""simple docstring"""

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






				class _UpperCamelCase							(							__A   ):
							'''simple docstring'''







							pass

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


import os
import tempfile
import unittest

from transformers.models.marian.convert_marian_tatoeba_to_pytorch import DEFAULT_REPO, TatoebaConverter
from transformers.testing_utils import slow
from transformers.utils import cached_property






@unittest.skipUnless(os.path.exists(__A   )							,	'Tatoeba directory does not exist.'   )
class _UpperCamelCase							(							unittest.TestCase   ):
			'''simple docstring'''







			@cached_property
			def 							__UpperCamelCase (			self							: Any	)							->       str:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       tempfile.mkdtemp()
				return TatoebaConverter(save_dir=a	)
			@slow
			def 							__UpperCamelCase (			self							: List[Any]	)							->       int:

				"""simple docstring"""

				self.resolver.convert_models(["heb-eng"]	)






			@slow
			def 							__UpperCamelCase (			self							: Optional[int]	)							->       Dict:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE     ,SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       self.resolver.write_model_card("opus-mt-he-en"      ,      dry_run=a	)
				assert mmeta["long_pair"] == "heb-eng"