



"""simple docstring"""
import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import MaskFormerSwinBackbone
			from transformers.models.maskformer import MaskFormerSwinModel


class 				lowerCamelCase_:





					'''simple docstring'''



					def __init__(     self					,							lowerCamelCase__					,							lowerCamelCase__=1_3					,							lowerCamelCase__=3_2					,							lowerCamelCase__=2					,							lowerCamelCase__=3					,							lowerCamelCase__=1_6					,							lowerCamelCase__=[1, 2, 1]					,							lowerCamelCase__=[2, 2, 4]					,							lowerCamelCase__=2					,							lowerCamelCase__=2.0					,							lowerCamelCase__=True					,							lowerCamelCase__=0.0					,							lowerCamelCase__=0.0					,							lowerCamelCase__=0.1					,							lowerCamelCase__="gelu"					,							lowerCamelCase__=False					,							lowerCamelCase__=True					,							lowerCamelCase__=0.0_2					,							lowerCamelCase__=1e-5					,							lowerCamelCase__=True					,							lowerCamelCase__=None					,							lowerCamelCase__=True					,							lowerCamelCase__=1_0					,							lowerCamelCase__=8					,							lowerCamelCase__=["stage1", "stage2", "stage3"]					,							lowerCamelCase__=[1, 2, 3]					,							):
									_lowerCamelCase   	=					parent
									_lowerCamelCase   	=					batch_size
									_lowerCamelCase   	=					image_size
									_lowerCamelCase   	=					patch_size
									_lowerCamelCase   	=					num_channels
									_lowerCamelCase   	=					embed_dim
									_lowerCamelCase   	=					depths
									_lowerCamelCase   	=					num_heads
									_lowerCamelCase   	=					window_size
									_lowerCamelCase   	=					mlp_ratio
									_lowerCamelCase   	=					qkv_bias
									_lowerCamelCase   	=					hidden_dropout_prob
									_lowerCamelCase   	=					attention_probs_dropout_prob
									_lowerCamelCase   	=					drop_path_rate
									_lowerCamelCase   	=					hidden_act
									_lowerCamelCase   	=					use_absolute_embeddings
									_lowerCamelCase   	=					patch_norm
									_lowerCamelCase   	=					layer_norm_eps
									_lowerCamelCase   	=					initializer_range
									_lowerCamelCase   	=					is_training
									_lowerCamelCase   	=					scope
									_lowerCamelCase   	=					use_labels
									_lowerCamelCase   	=					type_sequence_label_size
									_lowerCamelCase   	=					encoder_stride
									_lowerCamelCase   	=					out_features
									_lowerCamelCase   	=					out_indices

					def       snake_case__   (     self ):
									_lowerCamelCase   	=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

									_lowerCamelCase   	=					None
									if self.use_labels:
													_lowerCamelCase   	=					ids_tensor([self.batch_size]					,							self.type_sequence_label_size )

									_lowerCamelCase   	=					self.get_config()

									return config, pixel_values, labels

					def       snake_case__   (     self ):
									return MaskFormerSwinConfig(
									    image_size=self.image_size					,							patch_size=self.patch_size					,							num_channels=self.num_channels					,							embed_dim=self.embed_dim					,							depths=self.depths					,							num_heads=self.num_heads					,							window_size=self.window_size					,							mlp_ratio=self.mlp_ratio					,							qkv_bias=self.qkv_bias					,							hidden_dropout_prob=self.hidden_dropout_prob					,							attention_probs_dropout_prob=self.attention_probs_dropout_prob					,							drop_path_rate=self.drop_path_rate					,							hidden_act=self.hidden_act					,							use_absolute_embeddings=self.use_absolute_embeddings					,							path_norm=self.patch_norm					,							layer_norm_eps=self.layer_norm_eps					,							initializer_range=self.initializer_range					,							encoder_stride=self.encoder_stride					,							out_features=self.out_features					,							out_indices=self.out_indices					,							)

					def       snake_case__   (     self					,							lowerCamelCase__					,							lowerCamelCase__					,							lowerCamelCase__ ):
									_lowerCamelCase   	=					MaskFormerSwinModel(config=__lowerCAmelCase )
									model.to(__lowerCAmelCase )
									model.eval()
									_lowerCamelCase   	=					model(__lowerCAmelCase )

									_lowerCamelCase   	=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
									_lowerCamelCase   	=					int(config.embed_dim * 2 ** (len(config.depths ) - 1) )

									self.parent.assertEqual(result.last_hidden_state.shape					,							(self.batch_size, expected_seq_len, expected_dim) )

					def       snake_case__   (     self					,							lowerCamelCase__					,							lowerCamelCase__					,							lowerCamelCase__ ):
									_lowerCamelCase   	=					MaskFormerSwinBackbone(config=__lowerCAmelCase )
									model.to(__lowerCAmelCase )
									model.eval()
									_lowerCamelCase   	=					model(__lowerCAmelCase )

									# verify feature maps
									self.parent.assertEqual(len(result.feature_maps )					,							len(config.out_features ) )
									self.parent.assertListEqual(list(result.feature_maps[0].shape )					,							[1_3, 1_6, 1_6, 1_6] )

									# verify channels
									self.parent.assertEqual(len(model.channels )					,							len(config.out_features ) )
									self.parent.assertListEqual(model.channels					,							[1_6, 3_2, 6_4] )

									# verify ValueError
									with self.parent.assertRaises(__lowerCAmelCase ):
													_lowerCamelCase   	=					['''stem''']
													_lowerCamelCase   	=					MaskFormerSwinBackbone(config=__lowerCAmelCase )





					def       snake_case__   (     self ):
									_lowerCamelCase   	=					self.prepare_config_and_inputs()
									_lowerCamelCase	,  _lowerCamelCase	,  _lowerCamelCase   	=					config_and_inputs
									_lowerCamelCase   	=					{'''pixel_values''': pixel_values}
									return config, inputs_dict


@require_torch
class 				lowerCamelCase_( lowerCAmelCase_,					lowerCAmelCase_,					unittest.TestCase     ):





					'''simple docstring'''



					lowercase__ :							str              =			(
					    (
					        MaskFormerSwinModel,
					        MaskFormerSwinBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					lowercase__ :							List[str]              =			{'feature-extraction': MaskFormerSwinModel} if is_torch_available() else {}
					lowercase__ :							Any              =			False
					lowercase__ :							int              =			False
					lowercase__ :							Optional[Any]              =			False
					lowercase__ :							Optional[int]              =			False
					lowercase__ :							Optional[Any]              =			False

					def       snake_case__   (     self ):
									_lowerCamelCase   	=					MaskFormerSwinModelTester(self )
									_lowerCamelCase   	=					ConfigTester(self					,							config_class=__lowerCAmelCase					,							embed_dim=3_7 )

					@require_torch_multi_gpu
					@unittest.skip(
					    reason=(
					        '''`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'''
					        ''' `nn.DataParallel`'''
					    ) )
					def       snake_case__   (     self ):
									pass

					def       snake_case__   (     self ):
									self.create_and_test_config_common_properties()
									self.config_tester.create_and_test_config_to_json_string()
									self.config_tester.create_and_test_config_to_json_file()
									self.config_tester.create_and_test_config_from_and_save_pretrained()
									self.config_tester.create_and_test_config_with_num_labels()
									self.config_tester.check_config_can_be_init_without_params()
									self.config_tester.check_config_arguments_init()

					def       snake_case__   (     self ):
									return

					def       snake_case__   (     self ):
									_lowerCamelCase   	=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__lowerCAmelCase )

					def       snake_case__   (     self ):
									_lowerCamelCase   	=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_backbone(*__lowerCAmelCase )

					@unittest.skip('''Swin does not use inputs_embeds''' )
					def       snake_case__   (     self ):
									pass

					@unittest.skip('''Swin does not support feedforward chunking''' )
					def       snake_case__   (     self ):
									pass

					def       snake_case__   (     self ):
									_lowerCamelCase	,  _lowerCamelCase   	=					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													_lowerCamelCase   	=					model_class(__lowerCAmelCase )
													self.assertIsInstance(model.get_input_embeddings()					,							(nn.Module) )
													_lowerCamelCase   	=					model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(__lowerCAmelCase					,							nn.Linear ) )

					def       snake_case__   (     self ):
									_lowerCamelCase	,  _lowerCamelCase   	=					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													_lowerCamelCase   	=					model_class(__lowerCAmelCase )
													_lowerCamelCase   	=					inspect.signature(model.forward )
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													_lowerCamelCase   	=					[*signature.parameters.keys()]

													_lowerCamelCase   	=					['''pixel_values''']
													self.assertListEqual(arg_names[:1]					,							__lowerCAmelCase )

					@unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions''' )
					def       snake_case__   (     self ):
									pass

					@unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone''' )
					def       snake_case__   (     self ):
									pass

					def       snake_case__   (     self					,							lowerCamelCase__					,							lowerCamelCase__					,							lowerCamelCase__					,							lowerCamelCase__ ):
									_lowerCamelCase   	=					model_class(__lowerCAmelCase )
									model.to(__lowerCAmelCase )
									model.eval()

									with torch.no_grad():
													_lowerCamelCase   	=					model(**self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase ) )

									_lowerCamelCase   	=					outputs.hidden_states

									_lowerCamelCase   	=					getattr(
									    self.model_tester					,							'''expected_num_hidden_layers'''					,							len(self.model_tester.depths ) + 1 )
									self.assertEqual(len(__lowerCAmelCase )					,							__lowerCAmelCase )

									# Swin has a different seq_length
									_lowerCamelCase   	=					(
									    config.patch_size
									    if isinstance(config.patch_size					,							collections.abc.Iterable )
									    else (config.patch_size, config.patch_size)
									)

									_lowerCamelCase   	=					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

									self.assertListEqual(
									    list(hidden_states[0].shape[-2:] )					,							[num_patches, self.model_tester.embed_dim]					,							)

					def       snake_case__   (     self ):
									_lowerCamelCase	,  _lowerCamelCase   	=					self.model_tester.prepare_config_and_inputs_for_common()

									_lowerCamelCase   	=					(
									    self.model_tester.image_size
									    if isinstance(self.model_tester.image_size					,							collections.abc.Iterable )
									    else (self.model_tester.image_size, self.model_tester.image_size)
									)

									for model_class in self.all_model_classes:
													_lowerCamelCase   	=					True
													self.check_hidden_states_output(__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase )

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													_lowerCamelCase   	=					True

													self.check_hidden_states_output(__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase )

					def       snake_case__   (     self ):
									_lowerCamelCase	,  _lowerCamelCase   	=					self.model_tester.prepare_config_and_inputs_for_common()
									_lowerCamelCase   	=					3

									_lowerCamelCase   	=					(
									    self.model_tester.image_size
									    if isinstance(self.model_tester.image_size					,							collections.abc.Iterable )
									    else (self.model_tester.image_size, self.model_tester.image_size)
									)
									_lowerCamelCase   	=					(
									    config.patch_size
									    if isinstance(config.patch_size					,							collections.abc.Iterable )
									    else (config.patch_size, config.patch_size)
									)

									_lowerCamelCase   	=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
									_lowerCamelCase   	=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

									for model_class in self.all_model_classes:
													_lowerCamelCase   	=					True
													self.check_hidden_states_output(__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase					,							(padded_height, padded_width) )

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													_lowerCamelCase   	=					True
													self.check_hidden_states_output(__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase					,							(padded_height, padded_width) )

					@unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints''' )
					def       snake_case__   (     self ):
									pass

					@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin''' )
					def       snake_case__   (     self ):
									pass

					@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin''' )
					def       snake_case__   (     self ):
									pass





					def       snake_case__   (     self ):
									_lowerCamelCase	,  _lowerCamelCase   	=					self.model_tester.prepare_config_and_inputs_for_common()

									def set_nan_tensor_to_zero(lowerCamelCase__ ):
													_lowerCamelCase   	=					0
													return t

									def check_equivalence(lowerCamelCase__					,							lowerCamelCase__					,							lowerCamelCase__					,							lowerCamelCase__={} ):
													with torch.no_grad():
																	_lowerCamelCase   	=					model(**__lowerCAmelCase					,							return_dict=__lowerCAmelCase					,							**__lowerCAmelCase )
																	_lowerCamelCase   	=					model(**__lowerCAmelCase					,							return_dict=__lowerCAmelCase					,							**__lowerCAmelCase ).to_tuple()

																	def recursive_check(lowerCamelCase__					,							lowerCamelCase__ ):
																					if isinstance(__lowerCAmelCase					,							(List, Tuple) ):
																									for tuple_iterable_value, dict_iterable_value in zip(__lowerCAmelCase					,							__lowerCAmelCase ):
																													recursive_check(__lowerCAmelCase					,							__lowerCAmelCase )
																					elif isinstance(__lowerCAmelCase					,							__lowerCAmelCase ):
																									for tuple_iterable_value, dict_iterable_value in zip(
																									    tuple_object.values()					,							dict_object.values() ):
																													recursive_check(__lowerCAmelCase					,							__lowerCAmelCase )
																					elif tuple_object is None:
																									return
																					else:
																									self.assertTrue(
																									    torch.allclose(
																									        set_nan_tensor_to_zero(__lowerCAmelCase )					,							set_nan_tensor_to_zero(__lowerCAmelCase )					,							atol=1e-5 )					,							msg=(
																									        '''Tuple and dict output are not equal. Difference:'''
																									        F""" {torch.max(torch.abs(tuple_object - dict_object ) )}. Tuple has `nan`:"""
																									        F""" {torch.isnan(__lowerCAmelCase ).any()} and `inf`: {torch.isinf(__lowerCAmelCase )}. Dict has"""
																									        F""" `nan`: {torch.isnan(__lowerCAmelCase ).any()} and `inf`: {torch.isinf(__lowerCAmelCase )}."""
																									    )					,							)

																	recursive_check(__lowerCAmelCase					,							__lowerCAmelCase )

									for model_class in self.all_model_classes:
													_lowerCamelCase   	=					model_class(__lowerCAmelCase )
													model.to(__lowerCAmelCase )
													model.eval()

													_lowerCamelCase   	=					self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase )
													_lowerCamelCase   	=					self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase )
													check_equivalence(__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase )

													_lowerCamelCase   	=					self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase					,							return_labels=__lowerCAmelCase )
													_lowerCamelCase   	=					self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase					,							return_labels=__lowerCAmelCase )
													check_equivalence(__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase )

													_lowerCamelCase   	=					self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase )
													_lowerCamelCase   	=					self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase )
													check_equivalence(__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase					,							{'''output_hidden_states''': True} )

													_lowerCamelCase   	=					self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase					,							return_labels=__lowerCAmelCase )
													_lowerCamelCase   	=					self._prepare_for_class(__lowerCAmelCase					,							__lowerCAmelCase					,							return_labels=__lowerCAmelCase )
													check_equivalence(__lowerCAmelCase					,							__lowerCAmelCase					,							__lowerCAmelCase					,							{'''output_hidden_states''': True} )


@require_torch
class 				lowerCamelCase_( unittest.TestCase,					lowerCAmelCase_     ):





					'''simple docstring'''



					lowercase__ :							List[Any]              =			(MaskFormerSwinBackbone,) if is_torch_available() else ()
					lowercase__ :							List[str]              =			MaskFormerSwinConfig

					def       snake_case__   (     self ):
									_lowerCamelCase   	=					MaskFormerSwinModelTester(self )





					def       snake_case__   (     self ):
									_lowerCamelCase	,  _lowerCamelCase   	=					self.model_tester.prepare_config_and_inputs_for_common()
									_lowerCamelCase   	=					inputs_dict['''pixel_values'''].shape[0]

									for backbone_class in self.all_model_classes:
													_lowerCamelCase   	=					backbone_class(__lowerCAmelCase )
													backbone.to(__lowerCAmelCase )
													backbone.eval()

													_lowerCamelCase   	=					backbone(**__lowerCAmelCase )

													# Test default outputs and verify feature maps
													self.assertIsInstance(outputs.feature_maps					,							__lowerCAmelCase )
													self.assertTrue(len(outputs.feature_maps ) == len(backbone.channels ) )
													for feature_map, n_channels in zip(outputs.feature_maps					,							backbone.channels ):
																	self.assertTrue(feature_map.shape[:2]					,							(batch_size, n_channels) )
													self.assertIsNone(outputs.hidden_states )
													self.assertIsNone(outputs.attentions )

													# Test output_hidden_states=True
													_lowerCamelCase   	=					backbone(**__lowerCAmelCase					,							output_hidden_states=__lowerCAmelCase )
													self.assertIsNotNone(outputs.hidden_states )
													self.assertTrue(len(outputs.hidden_states )					,							len(backbone.stage_names ) )
													# We skip the stem layer
													for hidden_states, n_channels in zip(outputs.hidden_states[1:]					,							backbone.channels ):
																	for hidden_state in hidden_states:
																					# Hidden states are in the format (batch_size, (height * width), n_channels)
																					_lowerCamelCase	,  _lowerCamelCase	,  _lowerCamelCase   	=					hidden_state.shape
																					self.assertTrue((h_batch_size, h_n_channels)					,							(batch_size, n_channels) )

																					# Test output_attentions=True
													if self.has_attentions:
																	_lowerCamelCase   	=					backbone(**__lowerCAmelCase					,							output_attentions=__lowerCAmelCase )
																	self.assertIsNotNone(outputs.attentions )

"""simple docstring"""


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 							a					(		lowerCAmelCase_						,				unittest.TestCase ):
    _snake_case  :	Dict  				=				MgpstrTokenizer
    _snake_case  :	Any  				=				False
    _snake_case  :	str  				=				{}
    _snake_case  :	Dict  				=				False


    def   lowerCAmelCase_	(       self						:	int       ):
      super().setUp()

      # fmt: off
      _UpperCAmelCase    			=   ["""[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
      _UpperCAmelCase    			=   dict(zip(__lowerCAmelCase ,					range(len(__lowerCAmelCase       )       )       )       )

      _UpperCAmelCase    			=   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   lowerCAmelCase_	(       self						:	Tuple ,					**__lowerCAmelCase						:	Dict       ):
      return MgpstrTokenizer.from_pretrained(self.tmpdirname ,					**__lowerCAmelCase       )


    def   lowerCAmelCase_	(       self						:	List[str] ,					__lowerCAmelCase						:	int       ):
      _UpperCAmelCase    			=   """tester"""
      _UpperCAmelCase    			=   """tester"""
      return input_text, output_text


    @unittest.skip("""MGP-STR always lower cases letters."""       )
    def   lowerCAmelCase_	(       self						:	Tuple       ):
      pass


    def   lowerCAmelCase_	(       self						:	Any       ):
      _UpperCAmelCase    			=   self.get_tokenizers(do_lower_case=__lowerCAmelCase       )
      for tokenizer in tokenizers:
        with self.subTest(f'''{tokenizer.__class__.__name__}'''       ):
          _UpperCAmelCase    			=   """[SPECIAL_TOKEN]"""

          tokenizer.add_special_tokens({"""cls_token""": special_token}       )
          _UpperCAmelCase    			=   tokenizer.encode([special_token] ,					add_special_tokens=__lowerCAmelCase       )
          self.assertEqual(len(__lowerCAmelCase       ) ,					1       )

          _UpperCAmelCase    			=   tokenizer.decode(__lowerCAmelCase ,					skip_special_tokens=__lowerCAmelCase       )
          self.assertTrue(special_token not in decoded       )


    def   lowerCAmelCase_	(       self						:	List[str]       ):
      _UpperCAmelCase    			=   self.get_tokenizers()
      for tokenizer in tokenizers:
        with self.subTest(f'''{tokenizer.__class__.__name__}'''       ):
          _UpperCAmelCase			,					_UpperCAmelCase    			=   self.get_input_output_texts(__lowerCAmelCase       )

          _UpperCAmelCase    			=   tokenizer.tokenize(__lowerCAmelCase       )
          _UpperCAmelCase    			=   tokenizer.convert_tokens_to_ids(__lowerCAmelCase       )
          _UpperCAmelCase    			=   tokenizer.encode(__lowerCAmelCase ,					add_special_tokens=__lowerCAmelCase       )
          self.assertListEqual(__lowerCAmelCase ,					__lowerCAmelCase       )

          _UpperCAmelCase    			=   tokenizer.convert_ids_to_tokens(__lowerCAmelCase       )
          self.assertNotEqual(len(__lowerCAmelCase       ) ,					0       )
          _UpperCAmelCase    			=   tokenizer.decode(__lowerCAmelCase       )
          self.assertIsInstance(__lowerCAmelCase ,					__lowerCAmelCase       )

          self.assertEqual(text_a.replace(""" """ ,					""""""       ) ,					__lowerCAmelCase       )


    @unittest.skip("""MGP-STR tokenizer only handles one sequence."""       )
    def   lowerCAmelCase_	(       self						:	List[str]       ):
      pass


    @unittest.skip("""inputs cannot be pretokenized in MgpstrTokenizer"""       )
    def   lowerCAmelCase_	(       self						:	Optional[int]       ):
      pass
