"""simple docstring"""




import unittest

from transformers import MraConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_torch_available():
     import torch

     from transformers import (
         MraForMaskedLM,
         MraForMultipleChoice,
         MraForQuestionAnswering,
         MraForSequenceClassification,
         MraForTokenClassification,
         MraModel,
     )
     from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST
class 						__A							:






     def __init__(		self    ,					a__    ,					a__=2    ,					a__=8    ,					a__=True    ,					a__=True    ,					a__=True    ,					a__=True    ,					a__=99    ,					a__=16    ,					a__=5    ,					a__=2    ,					a__=36    ,					a__="gelu"    ,					a__=0.0    ,					a__=0.0    ,					a__=512    ,					a__=16    ,					a__=2    ,					a__=0.0_2    ,					a__=3    ,					a__=4    ,					a__=None    ,					):
       _lowerCAmelCase						:	List[str]        =					parent
       _lowerCAmelCase						:	int        =					batch_size
       _lowerCAmelCase						:	Optional[int]        =					seq_length
       _lowerCAmelCase						:	Any        =					is_training
       _lowerCAmelCase						:	List[Any]        =					use_input_mask
       _lowerCAmelCase						:	Union[str, Any]        =					use_token_type_ids
       _lowerCAmelCase						:	Optional[int]        =					use_labels
       _lowerCAmelCase						:	Dict        =					vocab_size
       _lowerCAmelCase						:	Optional[int]        =					hidden_size
       _lowerCAmelCase						:	List[Any]        =					num_hidden_layers
       _lowerCAmelCase						:	Tuple        =					num_attention_heads
       _lowerCAmelCase						:	Dict        =					intermediate_size
       _lowerCAmelCase						:	int        =					hidden_act
       _lowerCAmelCase						:	List[str]        =					hidden_dropout_prob
       _lowerCAmelCase						:	Any        =					attention_probs_dropout_prob
       _lowerCAmelCase						:	List[str]        =					max_position_embeddings
       _lowerCAmelCase						:	List[Any]        =					type_vocab_size
       _lowerCAmelCase						:	int        =					type_sequence_label_size
       _lowerCAmelCase						:	int        =					initializer_range
       _lowerCAmelCase						:	str        =					num_labels
       _lowerCAmelCase						:	List[Any]        =					num_choices
       _lowerCAmelCase						:	Optional[int]        =					scope






     def    __A  (		self  ):
       _lowerCAmelCase						:	List[str]        =					ids_tensor([self.batch_size, self.seq_length]    ,					self.vocab_size  )

       _lowerCAmelCase						:	Union[str, Any]        =					None
       if self.use_input_mask:
         _lowerCAmelCase						:	Optional[int]        =					random_attention_mask([self.batch_size, self.seq_length]  )

       _lowerCAmelCase						:	Dict        =					None
       if self.use_token_type_ids:
         _lowerCAmelCase						:	Any        =					ids_tensor([self.batch_size, self.seq_length]    ,					self.type_vocab_size  )

       _lowerCAmelCase						:	List[Any]        =					None
       _lowerCAmelCase						:	Optional[Any]        =					None
       _lowerCAmelCase						:	Optional[Any]        =					None
       if self.use_labels:
         _lowerCAmelCase						:	Union[str, Any]        =					ids_tensor([self.batch_size]    ,					self.type_sequence_label_size  )
         _lowerCAmelCase						:	int        =					ids_tensor([self.batch_size, self.seq_length]    ,					self.num_labels  )
         _lowerCAmelCase						:	str        =					ids_tensor([self.batch_size]    ,					self.num_choices  )

       _lowerCAmelCase						:	Dict        =					self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






     def    __A  (		self  ):
       return MraConfig(
           vocab_size=self.vocab_size    ,					hidden_size=self.hidden_size    ,					num_hidden_layers=self.num_hidden_layers    ,					num_attention_heads=self.num_attention_heads    ,					intermediate_size=self.intermediate_size    ,					hidden_act=self.hidden_act    ,					hidden_dropout_prob=self.hidden_dropout_prob    ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,					max_position_embeddings=self.max_position_embeddings    ,					type_vocab_size=self.type_vocab_size    ,					is_decoder=a__    ,					initializer_range=self.initializer_range    ,					)






     def    __A  (		self  ):
       _lowerCAmelCase						:	Optional[int]        =					self.get_config()
       _lowerCAmelCase						:	str        =					300
       return config






     def    __A  (		self  ):
       (
           (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     
       )						:	int        =					self.prepare_config_and_inputs()

       _lowerCAmelCase						:	Dict        =					True
       _lowerCAmelCase						:	int        =					floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
       _lowerCAmelCase						:	Any        =					ids_tensor([self.batch_size, self.seq_length]    ,					vocab_size=2  )

       return (
           config,
           input_ids,
           token_type_ids,
           input_mask,
           sequence_labels,
           token_labels,
           choice_labels,
           encoder_hidden_states,
           encoder_attention_mask,
       )






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	int        =					MraModel(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:	Tuple        =					model(a__    ,					attention_mask=a__    ,					token_type_ids=a__  )
       _lowerCAmelCase						:	str        =					model(a__    ,					token_type_ids=a__  )
       _lowerCAmelCase						:	Tuple        =					model(a__  )
       self.parent.assertEqual(result.last_hidden_state.shape    ,					(self.batch_size, self.seq_length, self.hidden_size)  )






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					):
       _lowerCAmelCase						:	List[Any]        =					True
       _lowerCAmelCase						:	List[str]        =					MraModel(a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:	int        =					model(
           a__    ,					attention_mask=a__    ,					token_type_ids=a__    ,					encoder_hidden_states=a__    ,					encoder_attention_mask=a__    ,					)
       _lowerCAmelCase						:	Union[str, Any]        =					model(
           a__    ,					attention_mask=a__    ,					token_type_ids=a__    ,					encoder_hidden_states=a__    ,					)
       _lowerCAmelCase						:	List[Any]        =					model(a__    ,					attention_mask=a__    ,					token_type_ids=a__  )
       self.parent.assertEqual(result.last_hidden_state.shape    ,					(self.batch_size, self.seq_length, self.hidden_size)  )






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Optional[Any]        =					MraForMaskedLM(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:	Tuple        =					model(a__    ,					attention_mask=a__    ,					token_type_ids=a__    ,					labels=a__  )
       self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.seq_length, self.vocab_size)  )






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	int        =					MraForQuestionAnswering(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:	Optional[int]        =					model(
           a__    ,					attention_mask=a__    ,					token_type_ids=a__    ,					start_positions=a__    ,					end_positions=a__    ,					)
       self.parent.assertEqual(result.start_logits.shape    ,					(self.batch_size, self.seq_length)  )
       self.parent.assertEqual(result.end_logits.shape    ,					(self.batch_size, self.seq_length)  )






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	List[Any]        =					self.num_labels
       _lowerCAmelCase						:	Optional[int]        =					MraForSequenceClassification(a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:	Optional[Any]        =					model(a__    ,					attention_mask=a__    ,					token_type_ids=a__    ,					labels=a__  )
       self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.num_labels)  )






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Optional[Any]        =					self.num_labels
       _lowerCAmelCase						:	Optional[int]        =					MraForTokenClassification(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:	Optional[int]        =					model(a__    ,					attention_mask=a__    ,					token_type_ids=a__    ,					labels=a__  )
       self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.seq_length, self.num_labels)  )






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	List[Any]        =					self.num_choices
       _lowerCAmelCase						:	Tuple        =					MraForMultipleChoice(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:	List[Any]        =					input_ids.unsqueeze(1  ).expand(-1    ,					self.num_choices    ,					-1  ).contiguous()
       _lowerCAmelCase						:	Tuple        =					token_type_ids.unsqueeze(1  ).expand(-1    ,					self.num_choices    ,					-1  ).contiguous()
       _lowerCAmelCase						:	Optional[Any]        =					input_mask.unsqueeze(1  ).expand(-1    ,					self.num_choices    ,					-1  ).contiguous()
       _lowerCAmelCase						:	Union[str, Any]        =					model(
           a__    ,					attention_mask=a__    ,					token_type_ids=a__    ,					labels=a__    ,					)
       self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.num_choices)  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	Tuple        =					self.prepare_config_and_inputs()
       (
           (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     (
           _lowerCAmelCase
       )      ,     
       )						:	Union[str, Any]        =					config_and_inputs
       _lowerCAmelCase						:	str        =					{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
       return config, inputs_dict







@require_torch
class 						__A							(			SCREAMING_SNAKE_CASE_   ,     unittest.TestCase		):
     _UpperCamelCase							:      int		 =		(
         (
             MraModel,
             MraForMaskedLM,
             MraForMultipleChoice,
             MraForQuestionAnswering,
             MraForSequenceClassification,
             MraForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     _UpperCamelCase							:      Optional[Any]		 =		False
     _UpperCamelCase							:      Any		 =		False
     _UpperCamelCase							:      Any		 =		False
     _UpperCamelCase							:      Optional[Any]		 =		False

     _UpperCamelCase							:      Optional[Any]		 =		()






     def    __A  (		self  ):
       _lowerCAmelCase						:	List[str]        =					MraModelTester(self  )
       _lowerCAmelCase						:	List[Any]        =					ConfigTester(self    ,					config_class=a__    ,					hidden_size=37  )






     def    __A  (		self  ):
       self.config_tester.run_common_tests()






     def    __A  (		self  ):
       _lowerCAmelCase						:	Any        =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*a__  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	Optional[int]        =					self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
         _lowerCAmelCase						:	str        =					type
         self.model_tester.create_and_check_model(*a__  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	Dict        =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*a__  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	Dict        =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*a__  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	Dict        =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*a__  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	str        =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*a__  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	Optional[Any]        =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*a__  )






     @slow
     def    __A  (		self  ):
       for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCAmelCase						:	List[str]        =					MraModel.from_pretrained(a__  )
         self.assertIsNotNone(a__  )






     @unittest.skip(reason="""MRA does not output attentions"""  )
     def    __A  (		self  ):
       return







@require_torch
class 						__A							(			unittest.TestCase		):






     @slow
     def    __A  (		self  ):
       _lowerCAmelCase						:	Dict        =					MraModel.from_pretrained("""uw-madison/mra-base-512-4"""  )
       _lowerCAmelCase						:	str        =					torch.arange(256  ).unsqueeze(0  )

       with torch.no_grad():
         _lowerCAmelCase						:	List[Any]        =					model(a__  )[0]

       _lowerCAmelCase						:	Any        =					torch.Size((1, 256, 768)  )
       self.assertEqual(output.shape    ,					a__  )

       _lowerCAmelCase						:	str        =					torch.tensor(
           [[[-0.0_1_4_0, 0.0_8_3_0, -0.0_3_8_1], [0.1_5_4_6, 0.1_4_0_2, 0.0_2_2_0], [0.1_1_6_2, 0.0_8_5_1, 0.0_1_6_5]]]  )

       self.assertTrue(torch.allclose(output[:, :3, :3]    ,					a__    ,					atol=1e-4  )  )






     @slow
     def    __A  (		self  ):
       _lowerCAmelCase						:	Any        =					MraForMaskedLM.from_pretrained("""uw-madison/mra-base-512-4"""  )
       _lowerCAmelCase						:	int        =					torch.arange(256  ).unsqueeze(0  )

       with torch.no_grad():
         _lowerCAmelCase						:	Optional[Any]        =					model(a__  )[0]

       _lowerCAmelCase						:	str        =					50265

       _lowerCAmelCase						:	Optional[int]        =					torch.Size((1, 256, vocab_size)  )
       self.assertEqual(output.shape    ,					a__  )

       _lowerCAmelCase						:	int        =					torch.tensor(
           [[[9.2_5_9_5, -3.6_0_3_8, 1_1.8_8_1_9], [9.3_8_6_9, -3.2_6_9_3, 1_1.0_9_5_6], [1_1.8_5_2_4, -3.4_9_3_8, 1_3.1_2_1_0]]]  )

       self.assertTrue(torch.allclose(output[:, :3, :3]    ,					a__    ,					atol=1e-4  )  )






     @slow
     def    __A  (		self  ):
       _lowerCAmelCase						:	Dict        =					MraForMaskedLM.from_pretrained("""uw-madison/mra-base-4096-8-d3"""  )
       _lowerCAmelCase						:	str        =					torch.arange(4096  ).unsqueeze(0  )

       with torch.no_grad():
         _lowerCAmelCase						:	Any        =					model(a__  )[0]

       _lowerCAmelCase						:	List[Any]        =					50265

       _lowerCAmelCase						:	Tuple        =					torch.Size((1, 4096, vocab_size)  )
       self.assertEqual(output.shape    ,					a__  )

       _lowerCAmelCase						:	List[str]        =					torch.tensor(
           [[[5.4_7_8_9, -2.3_5_6_4, 7.5_0_6_4], [7.9_0_6_7, -1.3_3_6_9, 9.9_6_6_8], [9.0_7_1_2, -1.8_1_0_6, 7.0_3_8_0]]]  )

       self.assertTrue(torch.allclose(output[:, :3, :3]    ,					a__    ,					atol=1e-4  )  )





"""simple docstring"""




from ..utils import DummyObject, requires_backends
class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Optional[Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      List[Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      int		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      str		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Optional[int]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      List[Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      str		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Union[str, Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Optional[int]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      List[str]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Any		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      str		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Tuple		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      str		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Tuple		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      str		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Tuple		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      str		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Dict		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Dict		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Union[str, Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Tuple		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      List[Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Optional[int]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Optional[Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Optional[Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      List[Any]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      int		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      Dict		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      List[str]		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )







class 						__A							(			metaclass=SCREAMING_SNAKE_CASE_		):
     _UpperCamelCase							:      int		 =		["sentencepiece"]






     def __init__(		self    ,					*a__    ,					**a__  ):
       requires_backends(self    ,					["""sentencepiece"""]  )




