


import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / """utils"""))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
   from test_module.custom_tokenization_fast import CustomTokenizerFast
class 		__magic_name__						(unittest.TestCase				):





     '''simple docstring'''



     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       snake_case__						= 0

     @slow
     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
         snake_case__						= AutoTokenizer.from_pretrained(_a   )
         self.assertIsNotNone(_a   )
         self.assertIsInstance(_a     ,		(BertTokenizer, BertTokenizerFast)   )
         self.assertGreater(len(_a   )     ,		0   )

       for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
         snake_case__						= AutoTokenizer.from_pretrained(_a   )
         self.assertIsNotNone(_a   )
         self.assertIsInstance(_a     ,		(GPTaTokenizer, GPTaTokenizerFast)   )
         self.assertGreater(len(_a   )     ,		0   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       snake_case__						= AutoTokenizer.from_pretrained(_a   )
       self.assertIsInstance(_a     ,		(BertTokenizer, BertTokenizerFast)   )
       self.assertEqual(tokenizer.vocab_size     ,		12   )

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]   ):
       snake_case__						= AutoTokenizer.from_pretrained(_a   )
       self.assertIsInstance(_a     ,		(RobertaTokenizer, RobertaTokenizerFast)   )
       self.assertEqual(tokenizer.vocab_size     ,		20   )

     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]   ):
       snake_case__						= AutoConfig.from_pretrained(_a   )
       self.assertIsInstance(_a     ,		_a   )
       # Check that tokenizer_type ≠ model_type
       snake_case__						= AutoTokenizer.from_pretrained(_a     ,		config=_a   )
       self.assertIsInstance(_a     ,		(BertTokenizer, BertTokenizerFast)   )
       self.assertEqual(tokenizer.vocab_size     ,		12   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy('''./tests/fixtures/vocab.txt'''     ,		os.path.join(_a     ,		'''vocab.txt'''   )   )

         snake_case__						= AutoTokenizer.from_pretrained(_a     ,		tokenizer_type='''bert'''     ,		use_fast=_a   )
         self.assertIsInstance(_a     ,		_a   )

       with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy('''./tests/fixtures/vocab.json'''     ,		os.path.join(_a     ,		'''vocab.json'''   )   )
         shutil.copy('''./tests/fixtures/merges.txt'''     ,		os.path.join(_a     ,		'''merges.txt'''   )   )

         snake_case__						= AutoTokenizer.from_pretrained(_a     ,		tokenizer_type='''gpt2'''     ,		use_fast=_a   )
         self.assertIsInstance(_a     ,		_a   )

     @require_tokenizers
     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy('''./tests/fixtures/vocab.txt'''     ,		os.path.join(_a     ,		'''vocab.txt'''   )   )

         snake_case__						= AutoTokenizer.from_pretrained(_a     ,		tokenizer_type='''bert'''   )
         self.assertIsInstance(_a     ,		_a   )

       with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy('''./tests/fixtures/vocab.json'''     ,		os.path.join(_a     ,		'''vocab.json'''   )   )
         shutil.copy('''./tests/fixtures/merges.txt'''     ,		os.path.join(_a     ,		'''merges.txt'''   )   )

         snake_case__						= AutoTokenizer.from_pretrained(_a     ,		tokenizer_type='''gpt2'''   )
         self.assertIsInstance(_a     ,		_a   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       with pytest.raises(_a   ):
         AutoTokenizer.from_pretrained('''./'''     ,		tokenizer_type='''xxx'''   )

     @require_tokenizers
     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
         snake_case__						= tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased'''   )
         self.assertIsInstance(_a     ,		(BertTokenizer, BertTokenizerFast)   )

         if isinstance(_a     ,		_a   ):
           self.assertEqual(tokenizer.basic_tokenizer.do_lower_case     ,		_a   )
         else:
           self.assertEqual(tokenizer.do_lower_case     ,		_a   )

         self.assertEqual(tokenizer.model_max_length     ,		5_12   )

     @require_tokenizers
     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]   ):
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
         with self.assertRaisesRegex(
             _a     ,		'''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'''     ,		):
           snake_case__						= tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       # tests: https://github.com/huggingface/transformers/pull/13251
       # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
       # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
       snake_case__						= TOKENIZER_MAPPING.values()
       snake_case__						= []

       for slow_tok, fast_tok in tokenizers:
         if slow_tok is not None:
           tokenizer_names.append(slow_tok.__name__   )

         if fast_tok is not None:
           tokenizer_names.append(fast_tok.__name__   )

       for tokenizer_name in tokenizer_names:
         # must find the right class
         tokenizer_class_from_name(_a   )

     @require_tokenizers
     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''     ,		use_fast=_a   )     ,		_a   )
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''   )     ,		_a   )

     @require_tokenizers
     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       snake_case__						= AutoTokenizer.from_pretrained('''distilbert-base-uncased'''     ,		do_lower_case=_a   )
       snake_case__						= '''Hello, world. How are you?'''
       snake_case__						= tokenizer.tokenize(_a   )
       self.assertEqual('''[UNK]'''     ,		tokens[0]   )

       snake_case__						= AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''     ,		do_lower_case=_a   )
       snake_case__						= tokenizer.tokenize(_a   )
       self.assertEqual('''[UNK]'''     ,		tokens[0]   )

     @require_tokenizers
     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       snake_case__						= AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''   )
       self.assertEqual(type(_a   )     ,		_a   )
       self.assertEqual(tokenizer.model_max_length     ,		5_12   )
       self.assertEqual(tokenizer.vocab_size     ,		3_00_00   )
       self.assertEqual(tokenizer.unk_token     ,		'''[UNK]'''   )
       self.assertEqual(tokenizer.padding_side     ,		'''right'''   )
       self.assertEqual(tokenizer.truncation_side     ,		'''right'''   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       snake_case__						= AutoTokenizer.from_pretrained(_a   )
       self.assertIsInstance(_a     ,		(BertTokenizer, BertTokenizerFast)   )
       with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(_a   )
         snake_case__						= AutoTokenizer.from_pretrained(_a   )

       self.assertIsInstance(_a     ,		tokenizer.__class__   )
       self.assertEqual(tokenizera.vocab_size     ,		12   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       snake_case__						= AutoTokenizer.from_pretrained('''ctrl'''   )
       # There is no fast CTRL so this always gives us a slow tokenizer.
       self.assertIsInstance(_a     ,		_a   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       # Check we can load the tokenizer config of an online model.
       snake_case__						= get_tokenizer_config('''bert-base-cased'''   )
       snake_case__						= config.pop('''_commit_hash'''     ,		_a   )
       # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
       self.assertEqual(_a     ,		{'''do_lower_case''': False}   )

       # This model does not have a tokenizer_config so we get back an empty dict.
       snake_case__						= get_tokenizer_config(_a   )
       self.assertDictEqual(_a     ,		{}   )

       # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
       snake_case__						= AutoTokenizer.from_pretrained(_a   )
       with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(_a   )
         snake_case__						= get_tokenizer_config(_a   )

       # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
       self.assertEqual(config['''tokenizer_class''']     ,		'''BertTokenizer'''   )

     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]   ):
       try:
         AutoConfig.register('''custom'''     ,		_a   )

         AutoTokenizer.register(_a     ,		slow_tokenizer_class=_a   )
         # Trying to register something existing in the Transformers library will raise an error
         with self.assertRaises(_a   ):
           AutoTokenizer.register(_a     ,		slow_tokenizer_class=_a   )

         snake_case__						= CustomTokenizer.from_pretrained(_a   )
         with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(_a   )

           snake_case__						= AutoTokenizer.from_pretrained(_a   )
           self.assertIsInstance(_a     ,		_a   )

       finally:
         if "custom" in CONFIG_MAPPING._extra_content:
           del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in TOKENIZER_MAPPING._extra_content:
           del TOKENIZER_MAPPING._extra_content[CustomConfig]

     @require_tokenizers
     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       try:
         AutoConfig.register('''custom'''     ,		_a   )

         # Can register in two steps
         AutoTokenizer.register(_a     ,		slow_tokenizer_class=_a   )
         self.assertEqual(TOKENIZER_MAPPING[CustomConfig]     ,		(CustomTokenizer, None)   )
         AutoTokenizer.register(_a     ,		fast_tokenizer_class=_a   )
         self.assertEqual(TOKENIZER_MAPPING[CustomConfig]     ,		(CustomTokenizer, CustomTokenizerFast)   )

         del TOKENIZER_MAPPING._extra_content[CustomConfig]
         # Can register in one step
         AutoTokenizer.register(
             _a     ,		slow_tokenizer_class=_a     ,		fast_tokenizer_class=_a   )
         self.assertEqual(TOKENIZER_MAPPING[CustomConfig]     ,		(CustomTokenizer, CustomTokenizerFast)   )

         # Trying to register something existing in the Transformers library will raise an error
         with self.assertRaises(_a   ):
           AutoTokenizer.register(_a     ,		fast_tokenizer_class=_a   )

         # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
         # and that model does not have a tokenizer.json
         with tempfile.TemporaryDirectory() as tmp_dir:
           snake_case__						= BertTokenizerFast.from_pretrained(_a   )
           bert_tokenizer.save_pretrained(_a   )
           snake_case__						= CustomTokenizerFast.from_pretrained(_a   )

         with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(_a   )

           snake_case__						= AutoTokenizer.from_pretrained(_a   )
           self.assertIsInstance(_a     ,		_a   )

           snake_case__						= AutoTokenizer.from_pretrained(_a     ,		use_fast=_a   )
           self.assertIsInstance(_a     ,		_a   )

       finally:
         if "custom" in CONFIG_MAPPING._extra_content:
           del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in TOKENIZER_MAPPING._extra_content:
           del TOKENIZER_MAPPING._extra_content[CustomConfig]

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       # If remote code is not set, we will time out when asking whether to load the model.
       with self.assertRaises(_a   ):
         snake_case__						= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''   )
       # If remote code is disabled, we can't load this config.
       with self.assertRaises(_a   ):
         snake_case__						= AutoTokenizer.from_pretrained(
             '''hf-internal-testing/test_dynamic_tokenizer'''     ,		trust_remote_code=_a   )

       snake_case__						= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''     ,		trust_remote_code=_a   )
       self.assertTrue(tokenizer.special_attribute_present   )
       # Test tokenizer can be reloaded.
       with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(_a   )
         snake_case__						= AutoTokenizer.from_pretrained(_a     ,		trust_remote_code=_a   )
       self.assertTrue(reloaded_tokenizer.special_attribute_present   )

       if is_tokenizers_available():
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizerFast'''   )
         self.assertEqual(reloaded_tokenizer.__class__.__name__     ,		'''NewTokenizerFast'''   )

         # Test we can also load the slow version
         snake_case__						= AutoTokenizer.from_pretrained(
             '''hf-internal-testing/test_dynamic_tokenizer'''     ,		trust_remote_code=_a     ,		use_fast=_a   )
         self.assertTrue(tokenizer.special_attribute_present   )
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )
         # Test tokenizer can be reloaded.
         with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(_a   )
           snake_case__						= AutoTokenizer.from_pretrained(_a     ,		trust_remote_code=_a     ,		use_fast=_a   )
         self.assertEqual(reloaded_tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )
         self.assertTrue(reloaded_tokenizer.special_attribute_present   )
       else:
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )
         self.assertEqual(reloaded_tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )

     @require_tokenizers
     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       class 		__magic_name__						(snake_case_				):





            '''simple docstring'''



            __lowercase				:							Tuple	   =       False




       class 		__magic_name__						(snake_case_				):





            '''simple docstring'''



            __lowercase				:							List[str]	   =       NewTokenizer
            __lowercase				:							List[str]	   =       False

       try:
         AutoConfig.register('''custom'''     ,		_a   )
         AutoTokenizer.register(_a     ,		slow_tokenizer_class=_a   )
         AutoTokenizer.register(_a     ,		fast_tokenizer_class=_a   )
         # If remote code is not set, the default is to use local
         snake_case__						= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''   )
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizerFast'''   )
         self.assertFalse(tokenizer.special_attribute_present   )
         snake_case__						= AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''     ,		use_fast=_a   )
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )
         self.assertFalse(tokenizer.special_attribute_present   )

         # If remote code is disabled, we load the local one.
         snake_case__						= AutoTokenizer.from_pretrained(
             '''hf-internal-testing/test_dynamic_tokenizer'''     ,		trust_remote_code=_a   )
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizerFast'''   )
         self.assertFalse(tokenizer.special_attribute_present   )
         snake_case__						= AutoTokenizer.from_pretrained(
             '''hf-internal-testing/test_dynamic_tokenizer'''     ,		trust_remote_code=_a     ,		use_fast=_a   )
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )
         self.assertFalse(tokenizer.special_attribute_present   )

         # If remote is enabled, we load from the Hub
         snake_case__						= AutoTokenizer.from_pretrained(
             '''hf-internal-testing/test_dynamic_tokenizer'''     ,		trust_remote_code=_a   )
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizerFast'''   )
         self.assertTrue(tokenizer.special_attribute_present   )
         snake_case__						= AutoTokenizer.from_pretrained(
             '''hf-internal-testing/test_dynamic_tokenizer'''     ,		trust_remote_code=_a     ,		use_fast=_a   )
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )
         self.assertTrue(tokenizer.special_attribute_present   )

       finally:
         if "custom" in CONFIG_MAPPING._extra_content:
           del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in TOKENIZER_MAPPING._extra_content:
           del TOKENIZER_MAPPING._extra_content[CustomConfig]

     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       snake_case__						= AutoTokenizer.from_pretrained(
           '''hf-internal-testing/test_dynamic_tokenizer_legacy'''     ,		trust_remote_code=_a   )
       self.assertTrue(tokenizer.special_attribute_present   )
       if is_tokenizers_available():
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizerFast'''   )

         # Test we can also load the slow version
         snake_case__						= AutoTokenizer.from_pretrained(
             '''hf-internal-testing/test_dynamic_tokenizer_legacy'''     ,		trust_remote_code=_a     ,		use_fast=_a   )
         self.assertTrue(tokenizer.special_attribute_present   )
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )
       else:
         self.assertEqual(tokenizer.__class__.__name__     ,		'''NewTokenizer'''   )

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       with self.assertRaisesRegex(
           _a     ,		'''bert-base is not a local folder and is not a valid model identifier'''   ):
         snake_case__						= AutoTokenizer.from_pretrained('''bert-base'''   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]   ):
       with self.assertRaisesRegex(
           _a     ,		r'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''   ):
         snake_case__						= AutoTokenizer.from_pretrained(_a     ,		revision='''aaaaaa'''   )







     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       # Make sure we have cached the tokenizer.
       snake_case__						= AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''   )
       with RequestCounter() as counter:
         snake_case__						= AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''   )
         self.assertEqual(counter.get_request_count     ,		0   )
         self.assertEqual(counter.head_request_count     ,		1   )
         self.assertEqual(counter.other_request_count     ,		0   )





import pytest

from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs







@pytest.mark.parametrize(
    '''kwargs, expected'''							,   [
        ({'''num_shards''': 0, '''max_num_jobs''': 1}, []),
        ({'''num_shards''': 10, '''max_num_jobs''': 1}, [range(10				)]),
        ({'''num_shards''': 10, '''max_num_jobs''': 10}, [range(__lowerCAmelCase							,   i + 1				) for i in range(10				)]),
        ({'''num_shards''': 1, '''max_num_jobs''': 10}, [range(1				)]),
        ({'''num_shards''': 10, '''max_num_jobs''': 3}, [range(0							,   4				), range(4							,   7				), range(7							,   10				)]),
        ({'''num_shards''': 3, '''max_num_jobs''': 10}, [range(0							,   1				), range(1							,   2				), range(2							,   3				)]),
    ]							,   )
def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase				)    ->				Optional[int]:
  snake_case__						= _distribute_shards(**__lowerCAmelCase				)
  assert out == expected







@pytest.mark.parametrize(
    '''gen_kwargs, max_num_jobs, expected'''							,   [
        ({'''foo''': 0}, 10, [{'''foo''': 0}]),
        ({'''shards''': [0, 1, 2, 3]}, 1, [{'''shards''': [0, 1, 2, 3]}]),
        ({'''shards''': [0, 1, 2, 3]}, 4, [{'''shards''': [0]}, {'''shards''': [1]}, {'''shards''': [2]}, {'''shards''': [3]}]),
        ({'''shards''': [0, 1]}, 4, [{'''shards''': [0]}, {'''shards''': [1]}]),
        ({'''shards''': [0, 1, 2, 3]}, 2, [{'''shards''': [0, 1]}, {'''shards''': [2, 3]}]),
    ]							,   )
def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase				)    ->				Dict:
  snake_case__						= _split_gen_kwargs(__lowerCAmelCase							,   __lowerCAmelCase				)
  assert out == expected







@pytest.mark.parametrize(
    '''gen_kwargs, expected'''							,   [
        ({'''foo''': 0}, 1),
        ({'''shards''': [0]}, 1),
        ({'''shards''': [0, 1, 2, 3]}, 4),
        ({'''shards''': [0, 1, 2, 3], '''foo''': 0}, 4),
        ({'''shards''': [0, 1, 2, 3], '''other''': (0, 1)}, 4),
        ({'''shards''': [0, 1, 2, 3], '''shards2''': [0, 1]}, RuntimeError),
    ]							,   )
def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase				)    ->				List[Any]:
  if expected is RuntimeError:
    with pytest.raises(__lowerCAmelCase				):
      _number_of_shards_in_gen_kwargs(__lowerCAmelCase				)
  else:
    snake_case__						= _number_of_shards_in_gen_kwargs(__lowerCAmelCase				)
    assert out == expected

