



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


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

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

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





@contextlib.contextmanager
def 							A			(  )       ->				List[Any]:







			'''simple docstring'''
			print('Welcome!'					)
			yield
			print('Bye!'					)





@contextlib.contextmanager
def 							A			(  )       ->				Any:







			'''simple docstring'''
			print('Bonjour!'					)
			yield
			print('Au revoir!'					)







class     __lowerCAmelCase					(    unittest.TestCase		):



			def 					_lowerCamelCase (		self     :						List[Any])     ->					Any:



						"""simple docstring"""






						assert transformers.__spec__ is not None
						assert importlib.util.find_spec('transformers') is not None







class     __lowerCAmelCase					(    unittest.TestCase		):



			@unittest.mock.patch('sys.stdout'				,	new_callable=io.StringIO)
			def 					_lowerCamelCase (		self     :						Optional[Any]				,	A     :						Union[str, Any])     ->					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 					_lowerCamelCase (		self     :						int				,	A     :						int)     ->					Optional[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 					_lowerCamelCase (		self     :						str				,	A     :						Tuple)     ->					Union[str, Any]:



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



						"""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     __lowerCAmelCase					(    A		):
									pass





						self.assertEqual(find_labels(A)				,	['labels'])



			@require_tf
			def 					_lowerCamelCase (		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     __lowerCAmelCase					(    A		):
									pass





						self.assertEqual(find_labels(A)				,	['labels'])



			@require_flax
			def 					_lowerCamelCase (		self     :						str)     ->					List[Any]:



						"""simple docstring"""






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







						class     __lowerCAmelCase					(    A		):
									pass





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





def 							A			(  _UpperCAmelCase       :     int							,     _UpperCAmelCase       :     int					)       ->				str:







			'''simple docstring'''
			if a < 0 or b < 0:
						raise ValueError('the value of both inputs must be positive'					)

			_UpperCAmelCase	 =     str(bin(_UpperCAmelCase					)					)[2:]  # remove the leading "0b"
			_UpperCAmelCase	 =     str(bin(_UpperCAmelCase					)					)[2:]  # remove the leading "0b"

			_UpperCAmelCase	 =     max(len(_UpperCAmelCase					)							,     len(_UpperCAmelCase					)					)

			return "0b" + "".join(
			    str(int(char_a != char_b					)					)
			    for char_a, char_b in zip(a_binary.zfill(_UpperCAmelCase					)							,     b_binary.zfill(_UpperCAmelCase					)					)					)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
