


from typing import List

import numpy as np

def 			_a  (				SCREAMING_SNAKE_CASE	:				dict     ):







	"""simple docstring"""



	UpperCamelCase__					:    Dict          =   {key: len(SCREAMING_SNAKE_CASE     ) for key, value in gen_kwargs.items() if isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )}
	if len(set(lists_lengths.values()     )     ) > 1:
		raise RuntimeError(
		    (
		        '''Sharding is ambiguous for this dataset: '''
		        + '''we found several data sources lists of different lengths, and we don\'t know over which list we should parallelize:\n'''
		        + '''\n'''.join(F"\t- key {key} has length {length}" for key, length in lists_lengths.items()     )
		        + '''\nTo fix this, check the \'gen_kwargs\' and make sure to use lists only for data sources, '''
		        + '''and use tuples otherwise. In the end there should only be one single list, or several lists with the same length.'''
		    )     )
	UpperCamelCase__					:    str          =   max(lists_lengths.values()    , default=0     )
	return max(1    , SCREAMING_SNAKE_CASE     )

def 			_a  (				SCREAMING_SNAKE_CASE	:				int    , SCREAMING_SNAKE_CASE	:				int     ):







	"""simple docstring"""



	UpperCamelCase__					:    Optional[int]          =   []
	for group_idx in range(SCREAMING_SNAKE_CASE     ):
		UpperCamelCase__					:    Tuple          =   num_shards // max_num_jobs + (group_idx < (num_shards % max_num_jobs))
		if num_shards_to_add == 0:
			break
		UpperCamelCase__					:    Tuple          =   shards_indices_per_group[-1].stop if shards_indices_per_group else 0
		UpperCamelCase__					:    List[str]          =   range(SCREAMING_SNAKE_CASE    , start + num_shards_to_add     )
		shards_indices_per_group.append(SCREAMING_SNAKE_CASE     )
	return shards_indices_per_group

def 			_a  (				SCREAMING_SNAKE_CASE	:				dict    , SCREAMING_SNAKE_CASE	:				int     ):







	"""simple docstring"""



	UpperCamelCase__					:    Tuple          =   _number_of_shards_in_gen_kwargs(SCREAMING_SNAKE_CASE     )
	if num_shards == 1:
		return [dict(SCREAMING_SNAKE_CASE     )]
	else:
		UpperCamelCase__					:    Union[str, Any]          =   _distribute_shards(num_shards=SCREAMING_SNAKE_CASE    , max_num_jobs=SCREAMING_SNAKE_CASE     )
		return [
		    {
		        key: [value[shard_idx] for shard_idx in shard_indices_per_group[group_idx]]
		        if isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
		        else value
		        for key, value in gen_kwargs.items()
		    }
		    for group_idx in range(len(SCREAMING_SNAKE_CASE     )     )
		]

def 			_a  (				SCREAMING_SNAKE_CASE	:				List[dict]     ):







	"""simple docstring"""



	return {
	    key: [value for gen_kwargs in gen_kwargs_list for value in gen_kwargs[key]]
	    if isinstance(gen_kwargs_list[0][key]    , SCREAMING_SNAKE_CASE     )
	    else gen_kwargs_list[0][key]
	    for key in gen_kwargs_list[0]
	}






def 			_a  (				SCREAMING_SNAKE_CASE	:				np.random.Generator    , SCREAMING_SNAKE_CASE	:				dict     ):







	"""simple docstring"""



	UpperCamelCase__					:    str          =   {len(SCREAMING_SNAKE_CASE     ) for value in gen_kwargs.values() if isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )}
	UpperCamelCase__					:    Any          =   {}
	for size in list_sizes:
		UpperCamelCase__					:    Union[str, Any]          =   list(range(SCREAMING_SNAKE_CASE     )     )
		rng.shuffle(indices_per_size[size]     )
	# Now let's copy the gen_kwargs and shuffle the lists based on their sizes
	UpperCamelCase__					:    Optional[Any]          =   dict(SCREAMING_SNAKE_CASE     )
	for key, value in shuffled_kwargs.items():
		if isinstance(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ):
			UpperCamelCase__					:    Any          =   [value[i] for i in indices_per_size[len(SCREAMING_SNAKE_CASE     )]]
	return shuffled_kwargs






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

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

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

@contextlib.contextmanager
def 			_a  (				):







 """simple docstring"""



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

@contextlib.contextmanager
def 			_a  (				):







 """simple docstring"""



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

class       __magic_name__	(     unittest.TestCase):


     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      Any:





      '''simple docstring'''






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



class       __magic_name__	(     unittest.TestCase):


     @unittest.mock.patch('''sys.stdout'''							,	new_callable=io.StringIO			)
     def      UpperCAmelCase__	(      self							:     Union[str, Any]							,	lowerCamelCase__							:     Union[str, 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							:     Any							,	lowerCamelCase__							:     Union[str, Any]			)  ->      Dict:





      '''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							:     List[Any]							,	lowerCamelCase__							:     List[str]			)  ->      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							:     Tuple			)  ->      Optional[int]:





      '''simple docstring'''






      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''']			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''', '''next_sentence_label''']			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''start_positions''', '''end_positions''']			)

      class       __magic_name__	(     __lowerCAmelCase):
           pass



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


     @require_tf
     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      Tuple:





      '''simple docstring'''






      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''']			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''', '''next_sentence_label''']			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''start_positions''', '''end_positions''']			)

      class       __magic_name__	(     __lowerCAmelCase):
           pass



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


     @require_flax
     def      UpperCAmelCase__	(      self							:     str			)  ->      Optional[Any]:





      '''simple docstring'''






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

      class       __magic_name__	(     __lowerCAmelCase):
           pass



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


