





"""simple docstring"""






from typing import List

import numpy as np






def      lowercase__ (					lowerCAmelCase__   :			str			)    ->			Optional[int]:



			'''simple docstring'''
			a__  :	Optional[int]		 =			{key: len(_UpperCamelCase			) for key, value in gen_kwargs.items() if isinstance(_UpperCamelCase							,			_UpperCamelCase			)}
			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."
						    )			)
			a__  :	Dict		 =			max(lists_lengths.values()							,			default=0			)
			return max(1							,			_UpperCamelCase			)






def      lowercase__ (					lowerCAmelCase__   :			List[str]							,			lowerCAmelCase__   :			Optional[Any]			)    ->			int:



			'''simple docstring'''
			a__  :	List[Any]		 =			[]
			for group_idx in range(_UpperCamelCase			):
						a__  :	str		 =			num_shards // max_num_jobs + (group_idx < (num_shards % max_num_jobs))
						if num_shards_to_add == 0:
									break
						a__  :	Tuple		 =			shards_indices_per_group[-1].stop if shards_indices_per_group else 0
						a__  :	List[str]		 =			range(_UpperCamelCase							,			start + num_shards_to_add			)
						shards_indices_per_group.append(_UpperCamelCase			)
			return shards_indices_per_group






def      lowercase__ (					lowerCAmelCase__   :			str							,			lowerCAmelCase__   :			int			)    ->			Tuple:



			'''simple docstring'''
			a__  :	List[str]		 =			_number_of_shards_in_gen_kwargs(_UpperCamelCase			)
			if num_shards == 1:
						return [dict(_UpperCamelCase			)]
			else:
						a__  :	List[Any]		 =			_distribute_shards(num_shards=_UpperCamelCase							,			max_num_jobs=_UpperCamelCase			)
						return [
						    {
						        key: [value[shard_idx] for shard_idx in shard_indices_per_group[group_idx]]
						        if isinstance(_UpperCamelCase							,			_UpperCamelCase			)
						        else value
						        for key, value in gen_kwargs.items()
						    }
						    for group_idx in range(len(_UpperCamelCase			)			)
						]






def      lowercase__ (					lowerCAmelCase__   :			Dict			)    ->			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]							,			_UpperCamelCase			)
			    else gen_kwargs_list[0][key]
			    for key in gen_kwargs_list[0]
			}






def      lowercase__ (					lowerCAmelCase__   :			Any							,			lowerCAmelCase__   :			int			)    ->			Union[str, Any]:



			'''simple docstring'''
			a__  :	Tuple		 =			{len(_UpperCamelCase			) for value in gen_kwargs.values() if isinstance(_UpperCamelCase							,			_UpperCamelCase			)}
			a__  :	Dict		 =			{}
			for size in list_sizes:
						a__  :	List[str]		 =			list(range(_UpperCamelCase			)			)
						rng.shuffle(indices_per_size[size]			)
			# Now let's copy the gen_kwargs and shuffle the lists based on their sizes
			a__  :	Dict		 =			dict(_UpperCamelCase			)
			for key, value in shuffled_kwargs.items():
						if isinstance(_UpperCamelCase							,			_UpperCamelCase			):
									a__  :	str		 =			[value[i] for i in indices_per_size[len(_UpperCamelCase			)]]
			return shuffled_kwargs







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


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 		__SCREAMING_SNAKE_CASE       (	):


   """simple docstring"""




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




@contextlib.contextmanager
def 		__SCREAMING_SNAKE_CASE       (	):


   """simple docstring"""




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


class 							_UpperCAmelCase    (		unittest.TestCase      ):




    def 					lowerCAmelCase__					(      self	:							int      ):






       '''simple docstring'''






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


class 							_UpperCAmelCase    (		unittest.TestCase      ):




    @unittest.mock.patch("sys.stdout"	,  new_callable=io.StringIO      )
    def 					lowerCAmelCase__					(      self	:							str	,  a	:							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	:							List[str]	,  a	:							Optional[int]      ):






       '''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	:							Tuple	,  a	:							List[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	:							Tuple      ):






       '''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    (		snake_case      ):
           pass


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




    @require_tf
    def 					lowerCAmelCase__					(      self	:							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 							_UpperCAmelCase    (		snake_case      ):
           pass


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





    @require_flax
    def 					lowerCAmelCase__					(      self	:							str      ):






       '''simple docstring'''






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


       class 							_UpperCAmelCase    (		snake_case      ):
           pass


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




