


'''simple docstring'''





from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


__lowerCamelCase       				=	logging.get_logger(__name__)

__lowerCamelCase       				=	{
    '''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json''',
    # See all MBART models at https://huggingface.co/models?filter=mbart
}




class 							UpperCAmelCase ( _snake_case	):
 UpperCAmelCase				=				"mbart"
 UpperCAmelCase				=				["past_key_values"]
 UpperCAmelCase				=				{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}


 def __init__(			self       :  int ,					__lowerCamelCase       :  Union[str, Any]=5_0_2_6_5 ,					__lowerCamelCase       :  Optional[int]=1_0_2_4 ,					__lowerCamelCase       :  List[str]=1_2 ,					__lowerCamelCase       :  Any=4_0_9_6 ,					__lowerCamelCase       :  List[Any]=1_6 ,					__lowerCamelCase       :  Any=1_2 ,					__lowerCamelCase       :  Optional[int]=4_0_9_6 ,					__lowerCamelCase       :  str=1_6 ,					__lowerCamelCase       :  Any=0.0 ,					__lowerCamelCase       :  Dict=0.0 ,					__lowerCamelCase       :  Tuple=True ,					__lowerCamelCase       :  str=True ,					__lowerCamelCase       :  Any="gelu" ,					__lowerCamelCase       :  List[Any]=1_0_2_4 ,					__lowerCamelCase       :  List[str]=0.1 ,					__lowerCamelCase       :  Tuple=0.0 ,					__lowerCamelCase       :  Optional[Any]=0.0 ,					__lowerCamelCase       :  Optional[int]=0.02 ,					__lowerCamelCase       :  int=0.0 ,					__lowerCamelCase       :  Optional[Any]=False ,					__lowerCamelCase       :  List[Any]=1 ,					__lowerCamelCase       :  Optional[int]=0 ,					__lowerCamelCase       :  Any=2 ,					__lowerCamelCase       :  Dict=2 ,					**__lowerCamelCase       :  str ,					):
    UpperCAmelCase__  :List[Any]            =			vocab_size
    UpperCAmelCase__  :str            =			max_position_embeddings
    UpperCAmelCase__  :List[str]            =			d_model
    UpperCAmelCase__  :Union[str, Any]            =			encoder_ffn_dim
    UpperCAmelCase__  :Tuple            =			encoder_layers
    UpperCAmelCase__  :Union[str, Any]            =			encoder_attention_heads
    UpperCAmelCase__  :Any            =			decoder_ffn_dim
    UpperCAmelCase__  :Optional[int]            =			decoder_layers
    UpperCAmelCase__  :Dict            =			decoder_attention_heads
    UpperCAmelCase__  :List[Any]            =			dropout
    UpperCAmelCase__  :Optional[Any]            =			attention_dropout
    UpperCAmelCase__  :Optional[Any]            =			activation_dropout
    UpperCAmelCase__  :List[Any]            =			activation_function
    UpperCAmelCase__  :List[str]            =			init_std
    UpperCAmelCase__  :Union[str, Any]            =			encoder_layerdrop
    UpperCAmelCase__  :List[str]            =			decoder_layerdrop
    UpperCAmelCase__  :Tuple            =			classifier_dropout
    UpperCAmelCase__  :str            =			use_cache
    UpperCAmelCase__  :Tuple            =			encoder_layers
    UpperCAmelCase__  :Dict            =			scale_embedding  # scale factor will be sqrt(d_model) if True
    super().__init__(
        pad_token_id=__lowerCamelCase ,					bos_token_id=__lowerCamelCase ,					eos_token_id=__lowerCamelCase ,					is_encoder_decoder=__lowerCamelCase ,					forced_eos_token_id=__lowerCamelCase ,					**__lowerCamelCase ,					)




class 							UpperCAmelCase ( _snake_case	):


 @property
 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[str]   ):
    if self.task in ["default", "seq2seq-lm"]:
       UpperCAmelCase__  :str            =			OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
           ]   )

       if self.use_past:
          UpperCAmelCase__  :Union[str, Any]            =			{0: '''batch'''}
          UpperCAmelCase__  :Union[str, Any]            =			{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
       else:
          UpperCAmelCase__  :Optional[int]            =			{0: '''batch''', 1: '''decoder_sequence'''}
          UpperCAmelCase__  :Dict            =			{0: '''batch''', 1: '''decoder_sequence'''}

       if self.use_past:
          self.fill_with_past_key_values_(__lowerCamelCase ,					direction='''inputs'''   )
    elif self.task == "causal-lm":
       # TODO: figure this case out.
       UpperCAmelCase__  :Tuple            =			OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
           ]   )
       if self.use_past:
          UpperCAmelCase__      ,	UpperCAmelCase__  :int            =			self.num_layers
          for i in range(__lowerCamelCase   ):
             UpperCAmelCase__  :Dict            =			{0: '''batch''', 2: '''past_sequence + sequence'''}
             UpperCAmelCase__  :Optional[Any]            =			{0: '''batch''', 2: '''past_sequence + sequence'''}
    else:
       UpperCAmelCase__  :Dict            =			OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
               ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
           ]   )

    return common_inputs


 @property
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any]   ):
    if self.task in ["default", "seq2seq-lm"]:
       UpperCAmelCase__  :Optional[int]            =			super().outputs
    else:
       UpperCAmelCase__  :List[str]            =			super(__lowerCamelCase ,					self   ).outputs
       if self.use_past:
          UpperCAmelCase__      ,	UpperCAmelCase__  :Optional[int]            =			self.num_layers
          for i in range(__lowerCamelCase   ):
             UpperCAmelCase__  :List[Any]            =			{0: '''batch''', 2: '''past_sequence + sequence'''}
             UpperCAmelCase__  :List[str]            =			{0: '''batch''', 2: '''past_sequence + sequence'''}
    return common_outputs


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict ,					__lowerCamelCase       :  PreTrainedTokenizer ,					__lowerCamelCase       :  int = -1 ,					__lowerCamelCase       :  int = -1 ,					__lowerCamelCase       :  bool = False ,					__lowerCamelCase       :  Optional[TensorType] = None ,					):
    UpperCAmelCase__  :str            =			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        __lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase   )

    # Generate decoder inputs
    UpperCAmelCase__  :int            =			seq_length if not self.use_past else 1
    UpperCAmelCase__  :Union[str, Any]            =			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        __lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase   )
    UpperCAmelCase__  :Dict            =			{f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
    UpperCAmelCase__  :Optional[Any]            =			dict(**__lowerCamelCase ,					**__lowerCamelCase   )

    if self.use_past:
       if not is_torch_available():
          raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''   )
       else:
          import torch
       UpperCAmelCase__      ,	UpperCAmelCase__  :Any            =			common_inputs['''input_ids'''].shape
       UpperCAmelCase__  :Dict            =			common_inputs['''decoder_input_ids'''].shape[1]
       UpperCAmelCase__      ,	UpperCAmelCase__  :int            =			self.num_attention_heads
       UpperCAmelCase__  :Optional[Any]            =			(
           batch,
           num_encoder_attention_heads,
           encoder_seq_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )
       UpperCAmelCase__  :str            =			decoder_seq_length + 3
       UpperCAmelCase__  :Union[str, Any]            =			(
           batch,
           num_decoder_attention_heads,
           decoder_past_length,
           self._config.hidden_size // num_decoder_attention_heads,
       )

       UpperCAmelCase__  :List[str]            =			torch.cat(
           [common_inputs['''decoder_attention_mask'''], torch.ones(__lowerCamelCase ,					__lowerCamelCase   )] ,					dim=1   )

       UpperCAmelCase__  :List[Any]            =			[]
       # If the number of encoder and decoder layers are present in the model configuration, both are considered
       UpperCAmelCase__      ,	UpperCAmelCase__  :Union[str, Any]            =			self.num_layers
       UpperCAmelCase__  :Union[str, Any]            =			min(__lowerCamelCase ,					__lowerCamelCase   )
       UpperCAmelCase__  :List[Any]            =			max(__lowerCamelCase ,					__lowerCamelCase   ) - min_num_layers
       UpperCAmelCase__  :Optional[Any]            =			'''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

       for _ in range(__lowerCamelCase   ):
          common_inputs["past_key_values"].append(
              (
                  torch.zeros(__lowerCamelCase   ),
                  torch.zeros(__lowerCamelCase   ),
                  torch.zeros(__lowerCamelCase   ),
                  torch.zeros(__lowerCamelCase   ),
              )   )
       # TODO: test this.
       UpperCAmelCase__  :Dict            =			encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
       for _ in range(__lowerCamelCase ,					__lowerCamelCase   ):
          common_inputs["past_key_values"].append((torch.zeros(__lowerCamelCase   ), torch.zeros(__lowerCamelCase   ))   )
    return common_inputs


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[int] ,					__lowerCamelCase       :  PreTrainedTokenizer ,					__lowerCamelCase       :  int = -1 ,					__lowerCamelCase       :  int = -1 ,					__lowerCamelCase       :  bool = False ,					__lowerCamelCase       :  Optional[TensorType] = None ,					):
    UpperCAmelCase__  :Tuple            =			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        __lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase   )

    if self.use_past:
       if not is_torch_available():
          raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''   )
       else:
          import torch
       UpperCAmelCase__      ,	UpperCAmelCase__  :Optional[Any]            =			common_inputs['''input_ids'''].shape
       # Not using the same length for past_key_values
       UpperCAmelCase__  :int            =			seqlen + 2
       UpperCAmelCase__      ,	UpperCAmelCase__  :List[Any]            =			self.num_layers
       UpperCAmelCase__      ,	UpperCAmelCase__  :List[Any]            =			self.num_attention_heads
       UpperCAmelCase__  :Optional[Any]            =			(
           batch,
           num_encoder_attention_heads,
           past_key_values_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )

       UpperCAmelCase__  :Tuple            =			common_inputs['''attention_mask'''].dtype
       UpperCAmelCase__  :List[Any]            =			torch.cat(
           [common_inputs['''attention_mask'''], torch.ones(__lowerCamelCase ,					__lowerCamelCase ,					dtype=__lowerCamelCase   )] ,					dim=1   )
       UpperCAmelCase__  :Dict            =			[
           (torch.zeros(__lowerCamelCase   ), torch.zeros(__lowerCamelCase   )) for _ in range(__lowerCamelCase   )
       ]
    return common_inputs


 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[str] ,					__lowerCamelCase       :  PreTrainedTokenizer ,					__lowerCamelCase       :  int = -1 ,					__lowerCamelCase       :  int = -1 ,					__lowerCamelCase       :  bool = False ,					__lowerCamelCase       :  Optional[TensorType] = None ,					):
    # Copied from OnnxConfig.generate_dummy_inputs
    # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
    # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
    UpperCAmelCase__  :int            =			compute_effective_axis_dimension(
        __lowerCamelCase ,					fixed_dimension=OnnxConfig.default_fixed_batch ,					num_token_to_add=0   )

    # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
    UpperCAmelCase__  :List[Any]            =			tokenizer.num_special_tokens_to_add(__lowerCamelCase   )
    UpperCAmelCase__  :Dict            =			compute_effective_axis_dimension(
        __lowerCamelCase ,					fixed_dimension=OnnxConfig.default_fixed_sequence ,					num_token_to_add=__lowerCamelCase   )

    # Generate dummy inputs according to compute batch and sequence
    UpperCAmelCase__  :Optional[Any]            =			[''' '''.join([tokenizer.unk_token]   ) * seq_length] * batch_size
    UpperCAmelCase__  :List[Any]            =			dict(tokenizer(__lowerCamelCase ,					return_tensors=__lowerCamelCase   )   )
    return common_inputs


 def 					__SCREAMING_SNAKE_CASE				(			self       :  str ,					__lowerCamelCase       :  PreTrainedTokenizer ,					__lowerCamelCase       :  int = -1 ,					__lowerCamelCase       :  int = -1 ,					__lowerCamelCase       :  bool = False ,					__lowerCamelCase       :  Optional[TensorType] = None ,					):
    if self.task in ["default", "seq2seq-lm"]:
       UpperCAmelCase__  :Any            =			self._generate_dummy_inputs_for_default_and_seqaseq_lm(
           __lowerCamelCase ,					batch_size=__lowerCamelCase ,					seq_length=__lowerCamelCase ,					is_pair=__lowerCamelCase ,					framework=__lowerCamelCase   )

    elif self.task == "causal-lm":
       UpperCAmelCase__  :List[Any]            =			self._generate_dummy_inputs_for_causal_lm(
           __lowerCamelCase ,					batch_size=__lowerCamelCase ,					seq_length=__lowerCamelCase ,					is_pair=__lowerCamelCase ,					framework=__lowerCamelCase   )
    else:
       UpperCAmelCase__  :Any            =			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           __lowerCamelCase ,					batch_size=__lowerCamelCase ,					seq_length=__lowerCamelCase ,					is_pair=__lowerCamelCase ,					framework=__lowerCamelCase   )

    return common_inputs





 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any] ,					__lowerCamelCase       :  Optional[int] ,					__lowerCamelCase       :  int ,					__lowerCamelCase       :  List[Any] ,					__lowerCamelCase       :  List[Any]   ):
    if self.task in ["default", "seq2seq-lm"]:
       UpperCAmelCase__  :List[str]            =			super()._flatten_past_key_values_(__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase   )
    else:
       UpperCAmelCase__  :Optional[Any]            =			super(__lowerCamelCase ,					self   )._flatten_past_key_values_(
           __lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase   )







'''simple docstring'''





import json
import os
import unittest

from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES, FSMTTokenizer
from transformers.testing_utils import slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


# using a different tiny model than the one used for default params defined in init to ensure proper testing
__lowerCamelCase       				=	'''stas/tiny-wmt19-en-ru'''




class 							UpperCAmelCase ( _snake_case	,   unittest.TestCase	):
 UpperCAmelCase				=				FSMTTokenizer
 UpperCAmelCase				=				False


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any]   ):
    super().setUp()

    # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
    UpperCAmelCase__  :Any            =			[
        '''l''',
        '''o''',
        '''w''',
        '''e''',
        '''r''',
        '''s''',
        '''t''',
        '''i''',
        '''d''',
        '''n''',
        '''w</w>''',
        '''r</w>''',
        '''t</w>''',
        '''lo''',
        '''low''',
        '''er</w>''',
        '''low</w>''',
        '''lowest</w>''',
        '''newer</w>''',
        '''wider</w>''',
        '''<unk>''',
    ]
    UpperCAmelCase__  :Dict            =			dict(zip(__lowerCamelCase ,					range(len(__lowerCamelCase   )   )   )   )
    UpperCAmelCase__  :Dict            =			['''l o 123''', '''lo w 1456''', '''e r</w> 1789''', '''''']

    UpperCAmelCase__  :Dict            =			['''en''', '''ru''']
    UpperCAmelCase__  :Tuple            =			{
        '''langs''': self.langs,
        '''src_vocab_size''': 1_0,
        '''tgt_vocab_size''': 2_0,
    }

    UpperCAmelCase__  :Any            =			os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES['''src_vocab_file''']   )
    UpperCAmelCase__  :Any            =			os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES['''tgt_vocab_file''']   )
    UpperCAmelCase__  :Dict            =			os.path.join(self.tmpdirname ,					'''tokenizer_config.json'''   )
    UpperCAmelCase__  :Union[str, Any]            =			os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES['''merges_file''']   )
    with open(self.src_vocab_file ,					'''w'''   ) as fp:
       fp.write(json.dumps(__lowerCamelCase   )   )
    with open(self.tgt_vocab_file ,					'''w'''   ) as fp:
       fp.write(json.dumps(__lowerCamelCase   )   )
    with open(self.merges_file ,					'''w'''   ) as fp:
       fp.write('''\n'''.join(__lowerCamelCase   )   )
    with open(__lowerCamelCase ,					'''w'''   ) as fp:
       fp.write(json.dumps(__lowerCamelCase   )   )


 @cached_property
 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[Any]   ):
    return FSMTTokenizer.from_pretrained('''facebook/wmt19-ru-en'''   )


 @cached_property
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Tuple   ):
    return FSMTTokenizer.from_pretrained('''facebook/wmt19-en-ru'''   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[Any]   ):
    UpperCAmelCase__  :int            =			FSMTTokenizer.from_pretrained(__lowerCamelCase   )
    self.assertListEqual([tokenizer.src_lang, tokenizer.tgt_lang] ,					['''en''', '''ru''']   )
    self.assertEqual(tokenizer.src_vocab_size ,					2_1   )
    self.assertEqual(tokenizer.tgt_vocab_size ,					2_1   )


 def 					__SCREAMING_SNAKE_CASE				(			self       :  Optional[int]   ):
    UpperCAmelCase__  :Tuple            =			FSMTTokenizer(self.langs ,					self.src_vocab_file ,					self.tgt_vocab_file ,					self.merges_file   )

    UpperCAmelCase__  :Any            =			'''lower'''
    UpperCAmelCase__  :List[Any]            =			['''low''', '''er</w>''']
    UpperCAmelCase__  :Union[str, Any]            =			tokenizer.tokenize(__lowerCamelCase   )
    self.assertListEqual(__lowerCamelCase ,					__lowerCamelCase   )

    UpperCAmelCase__  :Dict            =			tokens + ['''<unk>''']
    UpperCAmelCase__  :Union[str, Any]            =			[1_4, 1_5, 2_0]
    self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCamelCase   ) ,					__lowerCamelCase   )


 @slow
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Any   ):
    UpperCAmelCase__  :str            =			self.tokenizer_ru_en

    UpperCAmelCase__  :Union[str, Any]            =			tokenizer.encode('''sequence builders''' ,					add_special_tokens=__lowerCamelCase   )
    UpperCAmelCase__  :Dict            =			tokenizer.encode('''multi-sequence build''' ,					add_special_tokens=__lowerCamelCase   )

    UpperCAmelCase__  :Any            =			tokenizer.build_inputs_with_special_tokens(__lowerCamelCase   )
    UpperCAmelCase__  :Union[str, Any]            =			tokenizer.build_inputs_with_special_tokens(__lowerCamelCase ,					__lowerCamelCase   )

    assert encoded_sentence == text + [2]
    assert encoded_pair == text + [2] + text_a + [2]


 @slow
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any]   ):
    UpperCAmelCase__  :List[str]            =			self.tokenizer_en_ru
    UpperCAmelCase__  :Union[str, Any]            =			self.tokenizer_ru_en

    UpperCAmelCase__  :Any            =			[
        [
            '''Here\'s a little song I wrote. Don\'t worry, be happy.''',
            [2_4_7_0, 3_9, 1_1, 2_3_4_9, 7_2_2_2, 7_0, 5_9_7_9, 7, 8_4_5_0, 1_0_5_0, 1_3_1_6_0, 5, 2_6, 6_4_4_5, 7, 2],
        ],
        ['''This is it. No more. I\'m done!''', [1_3_2, 2_1, 3_7, 7, 1_4_3_4, 8_6, 7, 7_0, 6_4_7_6, 1_3_0_5, 4_2_7, 2]],
    ]

    # if data needs to be recreated or added, run:
    # import torch
    # model = torch.hub.load("pytorch/fairseq", "transformer.wmt19.en-ru", checkpoint_file="model4.pt", tokenizer="moses", bpe="fastbpe")
    # for src_text, _ in targets: print(f"""[\n"{src_text}",\n {model.encode(src_text).tolist()}\n],""")

    for src_text, tgt_input_ids in targets:
       UpperCAmelCase__  :List[Any]            =			tokenizer_enc.encode(__lowerCamelCase ,					return_tensors=__lowerCamelCase   )
       self.assertListEqual(__lowerCamelCase ,					__lowerCamelCase   )

       # and decode backward, using the reversed languages model
       UpperCAmelCase__  :str            =			tokenizer_dec.decode(__lowerCamelCase ,					skip_special_tokens=__lowerCamelCase   )
       self.assertEqual(__lowerCamelCase ,					__lowerCamelCase   )


 @slow
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Union[str, Any]   ):
    UpperCAmelCase__  :Optional[Any]            =			FSMTTokenizer.from_pretrained('''facebook/wmt19-ru-en''' ,					do_lower_case=__lowerCamelCase   )
    UpperCAmelCase__  :str            =			tokenizer.tokenize('''USA is United States of America'''   )
    UpperCAmelCase__  :str            =			['''us''', '''a</w>''', '''is</w>''', '''un''', '''i''', '''ted</w>''', '''st''', '''ates</w>''', '''of</w>''', '''am''', '''er''', '''ica</w>''']
    self.assertListEqual(__lowerCamelCase ,					__lowerCamelCase   )


 @unittest.skip('''FSMTConfig.__init__  requires non-optional args'''   )
 def 					__SCREAMING_SNAKE_CASE				(			self       :  List[str]   ):
    pass





 @unittest.skip('''FSMTConfig.__init__  requires non-optional args'''   )
 def 					__SCREAMING_SNAKE_CASE				(			self       :  Dict   ):
    pass



