

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__	   = DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

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

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



@contextlib.contextmanager
def 					lowerCAmelCase__							(	)			->      int:




				'''simple docstring'''





				print("Welcome!"      )
				yield
				print("Bye!"      )



@contextlib.contextmanager
def 					lowerCAmelCase__							(	)			->      int:




				'''simple docstring'''





				print("Bonjour!"      )
				yield
				print("Au revoir!"      )

class 					a__						(					unittest.TestCase			):
			"""simple docstring"""







			def      UpperCamelCase		(    self       )  ->						List[str]:
							'''simple docstring'''






							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      UpperCamelCase		(    self      ,      lowercase       )  ->						List[str]:
							'''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      ,      lowercase       )  ->						Union[str, 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      ,      lowercase       )  ->						Tuple:
							'''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[Any]:
							'''simple docstring'''






							self.assertEqual(find_labels(lowercase       )      ,      ["labels"]       )
							self.assertEqual(find_labels(lowercase       )      ,      ["labels", "next_sentence_label"]       )
							self.assertEqual(find_labels(lowercase       )      ,      ["start_positions", "end_positions"]       )

							class 					a__						(					snake_case			):
										"""simple docstring"""







										pass

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


			@require_tf
			def      UpperCamelCase		(    self       )  ->						str:
							'''simple docstring'''






							self.assertEqual(find_labels(lowercase       )      ,      ["labels"]       )
							self.assertEqual(find_labels(lowercase       )      ,      ["labels", "next_sentence_label"]       )
							self.assertEqual(find_labels(lowercase       )      ,      ["start_positions", "end_positions"]       )

							class 					a__						(					snake_case			):
										"""simple docstring"""







										pass

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


			@require_flax
			def      UpperCamelCase		(    self       )  ->						Union[str, Any]:
							'''simple docstring'''






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

							class 					a__						(					snake_case			):
										"""simple docstring"""







										pass

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




from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow


if is_tf_available():
	import numpy as np
	import tensorflow as tf

	from transformers import TFCamembertModel

@require_tf
@require_sentencepiece
@require_tokenizers
class 					a__						(					unittest.TestCase			):
			"""simple docstring"""







			@slow
			def      UpperCamelCase		(    self       )  ->						int:
							'''simple docstring'''






							A__        =			TFCamembertModel.from_pretrained("jplu/tf-camembert-base"       )

							A__        =			tf.convert_to_tensor(
							    [[5, 121, 11, 660, 16, 730, 25543, 110, 83, 6]]      ,      dtype=tf.intaa      ,      )  # J'aime le camembert !"

							A__        =			model(lowercase       )["last_hidden_state"]
							A__        =			tf.TensorShape((1, 10, 768)       )
							self.assertEqual(output.shape      ,      lowercase       )
							# compare the actual values for a slice.
							A__        =			tf.convert_to_tensor(
							    [[[-0.0254, 0.0235, 0.1027], [0.0606, -0.1811, -0.0418], [-0.1561, -0.1127, 0.2687]]]      ,      dtype=tf.floataa      ,      )
							# camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0')
							# camembert.eval()
							# expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()

							self.assertTrue(np.allclose(output[:, :3, :3].numpy()      ,      expected_slice.numpy()      ,      atol=1e-4       )       )

