


import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin







class 		_snake_case  (				_snake_case							):
 # to overwrite at feature extractactor specific tests
 SCREAMING_SNAKE_CASE__				=	None
 SCREAMING_SNAKE_CASE__				=	None




 @property
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       return self.feat_extract_tester.prepare_feat_extract_dict()




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Optional[Any]										=	self.feature_extraction_class(**self.feat_extract_dict   )
       self.assertTrue(hasattr(_lowerCamelCase ,  '''feature_size'''   )   )
       self.assertTrue(hasattr(_lowerCamelCase ,  '''sampling_rate'''   )   )
       self.assertTrue(hasattr(_lowerCamelCase ,  '''padding_value'''   )   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	self.feat_extract_tester.prepare_inputs_for_common()
       a						:Optional[Any]										=	self.feature_extraction_class(**self.feat_extract_dict   )
       a						:str										=	feat_extract.model_input_names[0]

       a						:Dict										=	BatchFeature({input_name: speech_inputs}   )

       self.assertTrue(all(len(_lowerCamelCase   ) == len(_lowerCamelCase   ) for x, y in zip(_lowerCamelCase ,  processed_features[input_name]   )   )   )

       a						:Dict										=	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase   )
       a						:Dict										=	BatchFeature({input_name: speech_inputs} ,  tensor_type='''np'''   )

       a						:Optional[int]										=	processed_features[input_name]

       if len(batch_features_input.shape   ) < 3:
             a						:List[Any]										=	batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )




 @require_torch
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase   )
       a						:List[str]										=	self.feature_extraction_class(**self.feat_extract_dict   )
       a						:Optional[int]										=	feat_extract.model_input_names[0]

       a						:str										=	BatchFeature({input_name: speech_inputs} ,  tensor_type='''pt'''   )

       a						:str										=	processed_features[input_name]

       if len(batch_features_input.shape   ) < 3:
             a						:Tuple										=	batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )




 @require_tf
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Optional[Any]										=	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase   )
       a						:Dict										=	self.feature_extraction_class(**self.feat_extract_dict   )
       a						:int										=	feat_extract.model_input_names[0]

       a						:Any										=	BatchFeature({input_name: speech_inputs} ,  tensor_type='''tf'''   )

       a						:List[str]										=	processed_features[input_name]

       if len(batch_features_input.shape   ) < 3:
             a						:Dict										=	batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase=False   ):
       def _inputs_have_equal_length(_lowerCamelCase   ):
             a						:Optional[Any]										=	len(input[0]   )
             for input_slice in input[1:]:
                   if len(_lowerCamelCase   ) != length:
                         return False
             return True

       def _inputs_are_equal(_lowerCamelCase ,  _lowerCamelCase   ):
             if len(_lowerCamelCase   ) != len(_lowerCamelCase   ):
                   return False

             for input_slice_a, input_slice_a in zip(_lowerCamelCase ,  _lowerCamelCase   ):
                   if not np.allclose(np.asarray(_lowerCamelCase   ) ,  np.asarray(_lowerCamelCase   ) ,  atol=1e-3   ):
                         return False
             return True

       a						:List[Any]										=	self.feature_extraction_class(**self.feat_extract_dict   )
       a						:Any										=	self.feat_extract_tester.prepare_inputs_for_common(numpify=_lowerCamelCase   )
       a						:int										=	feat_extract.model_input_names[0]

       a						:List[str]										=	BatchFeature({input_name: speech_inputs}   )

       a						:List[str]										=	self.feat_extract_tester.seq_length_diff
       a						:List[str]										=	self.feat_extract_tester.max_seq_length + pad_diff
       a						:Union[str, Any]										=	self.feat_extract_tester.min_seq_length
       a						:Union[str, Any]										=	self.feat_extract_tester.batch_size
       a						:Any										=	self.feat_extract_tester.feature_size

       # test padding for List[int] + numpy
       a						:int										=	feat_extract.pad(_lowerCamelCase ,  padding=_lowerCamelCase   )
       a						:str										=	input_a[input_name]

       a						:Any										=	feat_extract.pad(_lowerCamelCase ,  padding='''longest'''   )
       a						:Tuple										=	input_a[input_name]

       a						:str										=	feat_extract.pad(_lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[-1]   )   )
       a						:Union[str, Any]										=	input_a[input_name]

       a						:int										=	feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  return_tensors='''np'''   )
       a						:List[str]										=	input_a[input_name]

       # max_length parameter has to be provided when setting `padding="max_length"`
       with self.assertRaises(_lowerCamelCase   ):
             feat_extract.pad(_lowerCamelCase ,  padding='''max_length'''   )[input_name]

       a						:Dict										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=_lowerCamelCase ,  return_tensors='''np'''   )
       a						:Optional[int]										=	input_a[input_name]

       self.assertFalse(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertTrue(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertTrue(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertTrue(_inputs_are_equal(_lowerCamelCase ,  _lowerCamelCase   )   )
       self.assertTrue(len(input_a[0]   ) == pad_min_length   )
       self.assertTrue(len(input_a[1]   ) == pad_min_length + pad_diff   )
       self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]   ))   )
       self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)   )

       if feature_size > 1:
             self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size   )

       # test padding for `pad_to_multiple_of` for List[int] + numpy
       a						:Union[str, Any]										=	feat_extract.pad(_lowerCamelCase ,  pad_to_multiple_of=10   )
       a						:Union[str, Any]										=	input_a[input_name]

       a						:Any										=	feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  pad_to_multiple_of=10   )
       a						:List[str]										=	input_a[input_name]

       a						:Optional[Any]										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  pad_to_multiple_of=10 ,  max_length=_lowerCamelCase   )
       a						:List[str]										=	input_a[input_name]

       a						:Dict										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  pad_to_multiple_of=10 ,  max_length=_lowerCamelCase ,  return_tensors='''np''' ,  )
       a						:Union[str, Any]										=	input_a[input_name]

       self.assertTrue(all(len(_lowerCamelCase   ) % 10 == 0 for x in input_a   )   )
       self.assertTrue(_inputs_are_equal(_lowerCamelCase ,  _lowerCamelCase   )   )

       a						:Union[str, Any]										=	pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
       self.assertTrue(all(len(_lowerCamelCase   ) == expected_mult_pad_length for x in input_a   )   )
       self.assertEqual(input_a.shape[:2] ,  (batch_size, expected_mult_pad_length)   )

       if feature_size > 1:
             self.assertTrue(input_a.shape[2] == feature_size   )

       # Check padding value is correct
       a						:Any										=	(np.ones(self.feat_extract_tester.feature_size   ) * feat_extract.padding_value).sum()
       self.assertTrue(
           abs(np.asarray(input_a[0]   )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)   )
           < 1e-3   )
       self.assertTrue(
           abs(
               np.asarray(input_a[1]   )[pad_min_length + pad_diff :].sum()
               - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)   )
           < 1e-3   )
       self.assertTrue(
           abs(
               np.asarray(input_a[2]   )[pad_min_length + 2 * pad_diff :].sum()
               - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)   )
           < 1e-3   )
       self.assertTrue(
           abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)   ) < 1e-3   )
       self.assertTrue(
           abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)   )
           < 1e-3   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase=False   ):
       def _inputs_have_equal_length(_lowerCamelCase   ):
             a						:Any										=	len(input[0]   )
             for input_slice in input[1:]:
                   if len(_lowerCamelCase   ) != length:
                         return False
             return True

       def _inputs_are_equal(_lowerCamelCase ,  _lowerCamelCase   ):
             if len(_lowerCamelCase   ) != len(_lowerCamelCase   ):
                   return False

             for input_slice_a, input_slice_a in zip(_lowerCamelCase ,  _lowerCamelCase   ):
                   if not np.allclose(np.asarray(_lowerCamelCase   ) ,  np.asarray(_lowerCamelCase   ) ,  atol=1e-3   ):
                         return False
             return True

       a						:Optional[int]										=	self.feature_extraction_class(**self.feat_extract_dict   )
       a						:Optional[Any]										=	self.feat_extract_tester.prepare_inputs_for_common(numpify=_lowerCamelCase   )
       a						:Optional[int]										=	feat_extract.model_input_names[0]

       a						:Union[str, Any]										=	BatchFeature({input_name: speech_inputs}   )

       # truncate to smallest
       a						:Tuple										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[0]   ) ,  truncation=_lowerCamelCase   )
       a						:str										=	input_a[input_name]

       a						:str										=	feat_extract.pad(_lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[0]   )   )
       a						:Any										=	input_a[input_name]

       self.assertTrue(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertFalse(_inputs_have_equal_length(_lowerCamelCase   )   )

       # truncate to smallest with np
       a						:Dict										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[0]   ) ,  return_tensors='''np''' ,  truncation=_lowerCamelCase ,  )
       a						:Optional[int]										=	input_a[input_name]

       a						:List[str]										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[0]   ) ,  return_tensors='''np'''   )
       a						:Dict										=	input_a[input_name]

       self.assertTrue(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertTrue(input_a.shape[1] == len(speech_inputs[0]   )   )

       # since truncation forces padding to be smaller than longest input
       # function can't return `np.ndarray`, but has to return list
       self.assertFalse(_inputs_have_equal_length(_lowerCamelCase   )   )

       # truncate to middle
       a						:Union[str, Any]										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[1]   ) ,  truncation=_lowerCamelCase ,  return_tensors='''np''' ,  )
       a						:Any										=	input_a[input_name]

       a						:Tuple										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[1]   ) ,  truncation=_lowerCamelCase   )
       a						:List[Any]										=	input_a[input_name]

       a						:Optional[int]										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[1]   ) ,  return_tensors='''np'''   )
       a						:Optional[Any]										=	input_a[input_name]

       self.assertTrue(input_a.shape[1] == len(speech_inputs[1]   )   )
       self.assertTrue(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertTrue(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertTrue(_inputs_are_equal(_lowerCamelCase ,  _lowerCamelCase   )   )

       # since truncation forces padding to be smaller than longest input
       # function can't return `np.ndarray`, but has to return list
       self.assertFalse(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertTrue(len(input_a[-1]   ) == len(speech_inputs[-1]   )   )

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(_lowerCamelCase   ):
             feat_extract.pad(_lowerCamelCase ,  truncation=_lowerCamelCase   )[input_name]

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(_lowerCamelCase   ):
             feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  truncation=_lowerCamelCase   )[input_name]

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(_lowerCamelCase   ):
             feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  truncation=_lowerCamelCase   )[input_name]

       # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
       with self.assertRaises(_lowerCamelCase   ):
             feat_extract.pad(_lowerCamelCase ,  padding='''max_length''' ,  truncation=_lowerCamelCase   )[input_name]

       # test truncation for `pad_to_multiple_of` for List[int] + numpy
       a						:int										=	12
       a						:Union[str, Any]										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[0]   ) ,  pad_to_multiple_of=_lowerCamelCase ,  truncation=_lowerCamelCase ,  )
       a						:Dict										=	input_a[input_name]

       a						:Any										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=len(speech_inputs[0]   ) ,  pad_to_multiple_of=_lowerCamelCase ,  )
       a						:Dict										=	input_a[input_name]

       # retrieve expected_length as multiple of pad_to_multiple_of
       a						:Tuple										=	len(speech_inputs[0]   )
       if expected_length % pad_to_multiple_of != 0:
             a						:Dict										=	((len(speech_inputs[0]   ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

       self.assertTrue(len(input_a[0]   ) == expected_length   )
       self.assertTrue(_inputs_have_equal_length(_lowerCamelCase   )   )
       self.assertFalse(_inputs_have_equal_length(_lowerCamelCase   )   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self._check_padding(numpify=_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self._check_padding(numpify=_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self._check_truncation(numpify=_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self._check_truncation(numpify=_lowerCamelCase   )




 @require_torch
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Any										=	self.feature_extraction_class(**self.feat_extract_dict   )
       a						:str										=	self.feat_extract_tester.prepare_inputs_for_common()
       a						:List[str]										=	feat_extract.model_input_names[0]

       a						:Dict										=	BatchFeature({input_name: speech_inputs}   )

       a						:Optional[Any]										=	feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  return_tensors='''np'''   )[input_name]
       a						:Union[str, Any]										=	feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  return_tensors='''pt'''   )[input_name]

       self.assertTrue(abs(input_np.astype(np.floataa   ).sum() - input_pt.numpy().astype(np.floataa   ).sum()   ) < 1e-2   )




 @require_tf
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:int										=	self.feature_extraction_class(**self.feat_extract_dict   )
       a						:Dict										=	self.feat_extract_tester.prepare_inputs_for_common()
       a						:Optional[int]										=	feat_extract.model_input_names[0]

       a						:Optional[Any]										=	BatchFeature({input_name: speech_inputs}   )

       a						:Optional[int]										=	feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  return_tensors='''np'''   )[input_name]
       a						:int										=	feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  return_tensors='''tf'''   )[input_name]

       self.assertTrue(abs(input_np.astype(np.floataa   ).sum() - input_tf.numpy().astype(np.floataa   ).sum()   ) < 1e-2   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Optional[Any]										=	self.feat_extract_dict
       a						:List[Any]										=	True
       a						:List[Any]										=	self.feature_extraction_class(**_lowerCamelCase   )
       a						:Any										=	self.feat_extract_tester.prepare_inputs_for_common()
       a						:Optional[Any]										=	[len(_lowerCamelCase   ) for x in speech_inputs]
       a						:List[str]										=	feat_extract.model_input_names[0]

       a						:Tuple										=	BatchFeature({input_name: speech_inputs}   )

       a						:Any										=	feat_extract.pad(_lowerCamelCase ,  padding='''longest''' ,  return_tensors='''np'''   )
       self.assertIn('''attention_mask''' ,  _lowerCamelCase   )
       self.assertListEqual(list(processed.attention_mask.shape   ) ,  list(processed[input_name].shape[:2]   )   )
       self.assertListEqual(processed.attention_mask.sum(-1   ).tolist() ,  _lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Optional[int]										=	self.feat_extract_dict
       a						:Any										=	True
       a						:Optional[Any]										=	self.feature_extraction_class(**_lowerCamelCase   )
       a						:Optional[int]										=	self.feat_extract_tester.prepare_inputs_for_common()
       a						:int										=	[len(_lowerCamelCase   ) for x in speech_inputs]
       a						:Tuple										=	feat_extract.model_input_names[0]

       a						:List[str]										=	BatchFeature({input_name: speech_inputs}   )
       a						:Dict										=	min(_lowerCamelCase   )

       a						:Any										=	feat_extract.pad(
           _lowerCamelCase ,  padding='''max_length''' ,  max_length=_lowerCamelCase ,  truncation=_lowerCamelCase ,  return_tensors='''np'''   )
       self.assertIn('''attention_mask''' ,  _lowerCamelCase   )
       self.assertListEqual(
           list(processed_pad.attention_mask.shape   ) ,  [processed_pad[input_name].shape[0], max_length]   )
       self.assertListEqual(
           processed_pad.attention_mask[:, :max_length].sum(-1   ).tolist() ,  [max_length for x in speech_inputs]   )









import json
import os
import unittest

from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin







@require_tokenizers
class 		_snake_case  (				_snake_case						,   unittest.TestCase							):
 SCREAMING_SNAKE_CASE__				=	MgpstrTokenizer
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	{}
 SCREAMING_SNAKE_CASE__				=	False




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       super().setUp()

       # fmt: off
       a						:int										=	['''[GO]''', '''[s]''', '''0''', '''1''', '''2''', '''3''', '''4''', '''5''', '''6''', '''7''', '''8''', '''9''', '''a''', '''b''', '''c''', '''d''', '''e''', '''f''', '''g''', '''h''', '''i''', '''j''', '''k''', '''l''', '''m''', '''n''', '''o''', '''p''', '''q''', '''r''', '''s''', '''t''', '''u''', '''v''', '''w''', '''x''', '''y''', '''z''']
       # fmt: on
       a						:List[str]										=	dict(zip(_lowerCamelCase ,  range(len(_lowerCamelCase   )   )   )   )

       a						:Any										=	os.path.join(self.tmpdirname ,  VOCAB_FILES_NAMES['''vocab_file''']   )
       with open(self.vocab_file ,  '''w''' ,  encoding='''utf-8'''   ) as fp:
             fp.write(json.dumps(_lowerCamelCase   ) + '''\n'''   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  **_lowerCamelCase   ):
       return MgpstrTokenizer.from_pretrained(self.tmpdirname ,  **_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       a						:str										=	'''tester'''
       a						:Union[str, Any]										=	'''tester'''
       return input_text, output_text




 @unittest.skip('''MGP-STR always lower cases letters.'''   )
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       pass




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:List[Any]										=	self.get_tokenizers(do_lower_case=_lowerCamelCase   )
       for tokenizer in tokenizers:
             with self.subTest(F'''{tokenizer.__class__.__name__}'''   ):
                   a						:Any										=	'''[SPECIAL_TOKEN]'''

                   tokenizer.add_special_tokens({'''cls_token''': special_token}   )
                   a						:str										=	tokenizer.encode([special_token] ,  add_special_tokens=_lowerCamelCase   )
                   self.assertEqual(len(_lowerCamelCase   ) ,  1   )

                   a						:Tuple										=	tokenizer.decode(_lowerCamelCase ,  skip_special_tokens=_lowerCamelCase   )
                   self.assertTrue(special_token not in decoded   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Optional[Any]										=	self.get_tokenizers()
       for tokenizer in tokenizers:
             with self.subTest(F'''{tokenizer.__class__.__name__}'''   ):
                   a							,    a						:Tuple										=	self.get_input_output_texts(_lowerCamelCase   )

                   a						:Tuple										=	tokenizer.tokenize(_lowerCamelCase   )
                   a						:int										=	tokenizer.convert_tokens_to_ids(_lowerCamelCase   )
                   a						:Optional[int]										=	tokenizer.encode(_lowerCamelCase ,  add_special_tokens=_lowerCamelCase   )
                   self.assertListEqual(_lowerCamelCase ,  _lowerCamelCase   )

                   a						:Any										=	tokenizer.convert_ids_to_tokens(_lowerCamelCase   )
                   self.assertNotEqual(len(_lowerCamelCase   ) ,  0   )
                   a						:str										=	tokenizer.decode(_lowerCamelCase   )
                   self.assertIsInstance(_lowerCamelCase ,  _lowerCamelCase   )

                   self.assertEqual(text_a.replace(''' ''' ,  ''''''   ) ,  _lowerCamelCase   )




 @unittest.skip('''MGP-STR tokenizer only handles one sequence.'''   )
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       pass




 @unittest.skip('''inputs cannot be pretokenized in MgpstrTokenizer'''   )
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       pass





