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 __snake_case    :




       def __init__(   self      :    str	,     _lowercase      :    Any	,     _lowercase      :    Union[str, Any]=2	,     _lowercase      :    Optional[int]=8	,     _lowercase      :    str=True	,     _lowercase      :    str=True	,     _lowercase      :    Tuple=True	,     _lowercase      :    Union[str, Any]=True	,     _lowercase      :    Tuple=99	,     _lowercase      :    Optional[Any]=16	,     _lowercase      :    List[str]=5	,     _lowercase      :    Tuple=2	,     _lowercase      :    Optional[int]=36	,     _lowercase      :    List[str]="gelu"	,     _lowercase      :    Tuple=0.0	,     _lowercase      :    List[str]=0.0	,     _lowercase      :    int=5_12	,     _lowercase      :    Optional[int]=16	,     _lowercase      :    Dict=2	,     _lowercase      :    List[str]=0.02	,     _lowercase      :    Optional[int]=3	,     _lowercase      :    Tuple=4	,     _lowercase      :    Any=None	,     ):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				parent
         SCREAMING_SNAKE_CASE__      							=				batch_size
         SCREAMING_SNAKE_CASE__      							=				seq_length
         SCREAMING_SNAKE_CASE__      							=				is_training
         SCREAMING_SNAKE_CASE__      							=				use_input_mask
         SCREAMING_SNAKE_CASE__      							=				use_token_type_ids
         SCREAMING_SNAKE_CASE__      							=				use_labels
         SCREAMING_SNAKE_CASE__      							=				vocab_size
         SCREAMING_SNAKE_CASE__      							=				hidden_size
         SCREAMING_SNAKE_CASE__      							=				num_hidden_layers
         SCREAMING_SNAKE_CASE__      							=				num_attention_heads
         SCREAMING_SNAKE_CASE__      							=				intermediate_size
         SCREAMING_SNAKE_CASE__      							=				hidden_act
         SCREAMING_SNAKE_CASE__      							=				hidden_dropout_prob
         SCREAMING_SNAKE_CASE__      							=				attention_probs_dropout_prob
         SCREAMING_SNAKE_CASE__      							=				max_position_embeddings
         SCREAMING_SNAKE_CASE__      							=				type_vocab_size
         SCREAMING_SNAKE_CASE__      							=				type_sequence_label_size
         SCREAMING_SNAKE_CASE__      							=				initializer_range
         SCREAMING_SNAKE_CASE__      							=				num_labels
         SCREAMING_SNAKE_CASE__      							=				num_choices
         SCREAMING_SNAKE_CASE__      							=				scope




       def      __a						(   self      :    Union[str, Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				ids_tensor([self.batch_size, self.seq_length]	,     self.vocab_size				)

         SCREAMING_SNAKE_CASE__      							=				None
         if self.use_input_mask:
           SCREAMING_SNAKE_CASE__      							=				random_attention_mask([self.batch_size, self.seq_length]				)

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

         SCREAMING_SNAKE_CASE__      							=				None
         SCREAMING_SNAKE_CASE__      							=				None
         SCREAMING_SNAKE_CASE__      							=				None
         if self.use_labels:
           SCREAMING_SNAKE_CASE__      							=				ids_tensor([self.batch_size]	,     self.type_sequence_label_size				)
           SCREAMING_SNAKE_CASE__      							=				ids_tensor([self.batch_size, self.seq_length]	,     self.num_labels				)
           SCREAMING_SNAKE_CASE__      							=				ids_tensor([self.batch_size]	,     self.num_choices				)

         SCREAMING_SNAKE_CASE__      							=				self.get_config()

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




       def      __a						(   self      :    List[Any]				):



         """simple docstring"""






         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=_lowercase	,     initializer_range=self.initializer_range	,     )




       def      __a						(   self      :    Tuple				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.get_config()
         SCREAMING_SNAKE_CASE__      							=				3_00
         return config




       def      __a						(   self      :    str				):



         """simple docstring"""






         (
             (
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,										
         )      							=				self.prepare_config_and_inputs()

         SCREAMING_SNAKE_CASE__      							=				True
         SCREAMING_SNAKE_CASE__      							=				floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
         SCREAMING_SNAKE_CASE__      							=				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      :    str	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Dict	,     _lowercase      :    Tuple	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[int]	,     _lowercase      :    List[str]	,     _lowercase      :    List[str]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				MraModel(config=_lowercase				)
         model.to(_lowercase				)
         model.eval()
         SCREAMING_SNAKE_CASE__      							=				model(_lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				model(_lowercase	,     token_type_ids=_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				model(_lowercase				)
         self.parent.assertEqual(result.last_hidden_state.shape	,     (self.batch_size, self.seq_length, self.hidden_size)				)




       def      __a						(   self      :    List[Any]	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[int]	,     _lowercase      :    str	,     _lowercase      :    int	,     _lowercase      :    Any	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Any	,     _lowercase      :    str	,     ):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				True
         SCREAMING_SNAKE_CASE__      							=				MraModel(_lowercase				)
         model.to(_lowercase				)
         model.eval()
         SCREAMING_SNAKE_CASE__      							=				model(
             _lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase	,     encoder_hidden_states=_lowercase	,     encoder_attention_mask=_lowercase	,     )
         SCREAMING_SNAKE_CASE__      							=				model(
             _lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase	,     encoder_hidden_states=_lowercase	,     )
         SCREAMING_SNAKE_CASE__      							=				model(_lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase				)
         self.parent.assertEqual(result.last_hidden_state.shape	,     (self.batch_size, self.seq_length, self.hidden_size)				)




       def      __a						(   self      :    Optional[int]	,     _lowercase      :    Dict	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Union[str, Any]	,     _lowercase      :    Any	,     _lowercase      :    List[Any]	,     _lowercase      :    Tuple	,     _lowercase      :    int				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				MraForMaskedLM(config=_lowercase				)
         model.to(_lowercase				)
         model.eval()
         SCREAMING_SNAKE_CASE__      							=				model(_lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase	,     labels=_lowercase				)
         self.parent.assertEqual(result.logits.shape	,     (self.batch_size, self.seq_length, self.vocab_size)				)




       def      __a						(   self      :    List[str]	,     _lowercase      :    Union[str, Any]	,     _lowercase      :    Any	,     _lowercase      :    List[Any]	,     _lowercase      :    Tuple	,     _lowercase      :    Union[str, Any]	,     _lowercase      :    Optional[Any]	,     _lowercase      :    int				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				MraForQuestionAnswering(config=_lowercase				)
         model.to(_lowercase				)
         model.eval()
         SCREAMING_SNAKE_CASE__      							=				model(
             _lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase	,     start_positions=_lowercase	,     end_positions=_lowercase	,     )
         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      :    Tuple	,     _lowercase      :    int	,     _lowercase      :    Tuple	,     _lowercase      :    Dict	,     _lowercase      :    Tuple	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Optional[Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.num_labels
         SCREAMING_SNAKE_CASE__      							=				MraForSequenceClassification(_lowercase				)
         model.to(_lowercase				)
         model.eval()
         SCREAMING_SNAKE_CASE__      							=				model(_lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase	,     labels=_lowercase				)
         self.parent.assertEqual(result.logits.shape	,     (self.batch_size, self.num_labels)				)




       def      __a						(   self      :    Dict	,     _lowercase      :    List[str]	,     _lowercase      :    List[Any]	,     _lowercase      :    Optional[int]	,     _lowercase      :    Dict	,     _lowercase      :    int	,     _lowercase      :    Optional[int]	,     _lowercase      :    Any				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.num_labels
         SCREAMING_SNAKE_CASE__      							=				MraForTokenClassification(config=_lowercase				)
         model.to(_lowercase				)
         model.eval()
         SCREAMING_SNAKE_CASE__      							=				model(_lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase	,     labels=_lowercase				)
         self.parent.assertEqual(result.logits.shape	,     (self.batch_size, self.seq_length, self.num_labels)				)




       def      __a						(   self      :    Any	,     _lowercase      :    Union[str, Any]	,     _lowercase      :    List[Any]	,     _lowercase      :    Any	,     _lowercase      :    List[Any]	,     _lowercase      :    str	,     _lowercase      :    Any	,     _lowercase      :    Optional[Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.num_choices
         SCREAMING_SNAKE_CASE__      							=				MraForMultipleChoice(config=_lowercase				)
         model.to(_lowercase				)
         model.eval()
         SCREAMING_SNAKE_CASE__      							=				input_ids.unsqueeze(1				).expand(-1	,     self.num_choices	,     -1				).contiguous()
         SCREAMING_SNAKE_CASE__      							=				token_type_ids.unsqueeze(1				).expand(-1	,     self.num_choices	,     -1				).contiguous()
         SCREAMING_SNAKE_CASE__      							=				input_mask.unsqueeze(1				).expand(-1	,     self.num_choices	,     -1				).contiguous()
         SCREAMING_SNAKE_CASE__      							=				model(
             _lowercase	,     attention_mask=_lowercase	,     token_type_ids=_lowercase	,     labels=_lowercase	,     )
         self.parent.assertEqual(result.logits.shape	,     (self.batch_size, self.num_choices)				)




       def      __a						(   self      :    Dict				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.prepare_config_and_inputs()
         (
             (
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,					(
             SCREAMING_SNAKE_CASE__					
         )							,										
         )      							=				config_and_inputs
         SCREAMING_SNAKE_CASE__      							=				{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
         return config, inputs_dict







@require_torch
class __snake_case    (						lowerCamelCase_       ,		unittest.TestCase		):
       lowerCAmelCase_														=							(
           (
               MraModel,
               MraForMaskedLM,
               MraForMultipleChoice,
               MraForQuestionAnswering,
               MraForSequenceClassification,
               MraForTokenClassification,
           )
           if is_torch_available()
           else ()
       )
       lowerCAmelCase_														=							False
       lowerCAmelCase_														=							False
       lowerCAmelCase_														=							False
       lowerCAmelCase_														=							False

       lowerCAmelCase_														=							()




       def      __a						(   self      :    List[str]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				MraModelTester(self				)
         SCREAMING_SNAKE_CASE__      							=				ConfigTester(self	,     config_class=_lowercase	,     hidden_size=37				)




       def      __a						(   self      :    Union[str, Any]				):



         """simple docstring"""






         self.config_tester.run_common_tests()




       def      __a						(   self      :    Dict				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowercase				)




       def      __a						(   self      :    Tuple				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
           SCREAMING_SNAKE_CASE__      							=				type
           self.model_tester.create_and_check_model(*_lowercase				)




       def      __a						(   self      :    Tuple				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*_lowercase				)




       def      __a						(   self      :    Tuple				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*_lowercase				)




       def      __a						(   self      :    List[str]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*_lowercase				)




       def      __a						(   self      :    Union[str, Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*_lowercase				)




       def      __a						(   self      :    Dict				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*_lowercase				)




       @slow
       def      __a						(   self      :    Dict				):



         """simple docstring"""






         for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           SCREAMING_SNAKE_CASE__      							=				MraModel.from_pretrained(_lowercase				)
           self.assertIsNotNone(_lowercase				)




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



         """simple docstring"""






         return







@require_torch
class __snake_case    (						unittest.TestCase		):




       @slow
       def      __a						(   self      :    List[Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				MraModel.from_pretrained("""uw-madison/mra-base-512-4"""				)
         SCREAMING_SNAKE_CASE__      							=				torch.arange(2_56				).unsqueeze(0				)

         with torch.no_grad():
           SCREAMING_SNAKE_CASE__      							=				model(_lowercase				)[0]

         SCREAMING_SNAKE_CASE__      							=				torch.Size((1, 2_56, 7_68)				)
         self.assertEqual(output.shape	,     _lowercase				)

         SCREAMING_SNAKE_CASE__      							=				torch.tensor(
             [[[-0.01_40, 0.08_30, -0.03_81], [0.15_46, 0.14_02, 0.02_20], [0.11_62, 0.08_51, 0.01_65]]]				)

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




       @slow
       def      __a						(   self      :    str				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				MraForMaskedLM.from_pretrained("""uw-madison/mra-base-512-4"""				)
         SCREAMING_SNAKE_CASE__      							=				torch.arange(2_56				).unsqueeze(0				)

         with torch.no_grad():
           SCREAMING_SNAKE_CASE__      							=				model(_lowercase				)[0]

         SCREAMING_SNAKE_CASE__      							=				5_02_65

         SCREAMING_SNAKE_CASE__      							=				torch.Size((1, 2_56, vocab_size)				)
         self.assertEqual(output.shape	,     _lowercase				)

         SCREAMING_SNAKE_CASE__      							=				torch.tensor(
             [[[9.25_95, -3.60_38, 11.88_19], [9.38_69, -3.26_93, 11.09_56], [11.85_24, -3.49_38, 13.12_10]]]				)

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




       @slow
       def      __a						(   self      :    Optional[Any]				):



         """simple docstring"""






         SCREAMING_SNAKE_CASE__      							=				MraForMaskedLM.from_pretrained("""uw-madison/mra-base-4096-8-d3"""				)
         SCREAMING_SNAKE_CASE__      							=				torch.arange(40_96				).unsqueeze(0				)

         with torch.no_grad():
           SCREAMING_SNAKE_CASE__      							=				model(_lowercase				)[0]

         SCREAMING_SNAKE_CASE__      							=				5_02_65

         SCREAMING_SNAKE_CASE__      							=				torch.Size((1, 40_96, vocab_size)				)
         self.assertEqual(output.shape	,     _lowercase				)

         SCREAMING_SNAKE_CASE__      							=				torch.tensor(
             [[[5.47_89, -2.35_64, 7.50_64], [7.90_67, -1.33_69, 9.96_68], [9.07_12, -1.81_06, 7.03_80]]]				)

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

import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
   from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
   from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
   from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


__lowerCamelCase      :			Tuple							       =		DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

__lowerCamelCase      :			Optional[Any]							       =		'''main'''
# Default branch name
__lowerCamelCase      :			Optional[int]							       =		'''f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'''
# One particular commit (not the top of `main`)
__lowerCamelCase      :			Any							       =		'''aaaaaaa'''
# This commit does not exist, so we should 404.

__lowerCamelCase      :			List[str]							       =		'''d9e9f15bc825e4b2c9249e9578f884bbcb5e3684'''
# Sha-1 of config.json on the top of `main`, for checking purposes
__lowerCamelCase      :			List[Any]							       =		'''4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'''



@contextlib.contextmanager
def      __SCREAMING_SNAKE_CASE  ( )							-> str:







  """simple docstring"""





  print("""Welcome!"""     )
  yield
  print("""Bye!"""     )



@contextlib.contextmanager
def      __SCREAMING_SNAKE_CASE  ( )							-> Any:







  """simple docstring"""





  print("""Bonjour!"""     )
  yield
  print("""Au revoir!"""     )







class __snake_case    (						unittest.TestCase		):




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     assert transformers.__spec__ is not None
     assert importlib.util.find_spec("""transformers"""				) is not None







class __snake_case    (						unittest.TestCase		):




   @unittest.mock.patch("""sys.stdout"""	,     new_callable=io.StringIO				)
   def      __a						(   self      :    List[str]	,     _lowercase      :    str				):



     """simple docstring"""






     with ContextManagers([]				):
       print("""Transformers are awesome!"""				)
     # The print statement adds a new line at the end of the output
     self.assertEqual(mock_stdout.getvalue()	,     """Transformers are awesome!\n"""				)




   @unittest.mock.patch("""sys.stdout"""	,     new_callable=io.StringIO				)
   def      __a						(   self      :    Optional[Any]	,     _lowercase      :    str				):



     """simple docstring"""






     with ContextManagers([context_en()]				):
       print("""Transformers are awesome!"""				)
     # The output should be wrapped with an English welcome and goodbye
     self.assertEqual(mock_stdout.getvalue()	,     """Welcome!\nTransformers are awesome!\nBye!\n"""				)




   @unittest.mock.patch("""sys.stdout"""	,     new_callable=io.StringIO				)
   def      __a						(   self      :    Tuple	,     _lowercase      :    Dict				):



     """simple docstring"""






     with ContextManagers([context_fr(), context_en()]				):
       print("""Transformers are awesome!"""				)
     # The output should be wrapped with an English and French welcome and goodbye
     self.assertEqual(mock_stdout.getvalue()	,     """Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"""				)




   @require_torch
   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     self.assertEqual(find_labels(_lowercase				)	,     ["""labels"""]				)
     self.assertEqual(find_labels(_lowercase				)	,     ["""labels""", """next_sentence_label"""]				)
     self.assertEqual(find_labels(_lowercase				)	,     ["""start_positions""", """end_positions"""]				)







     class __snake_case    (						lowerCamelCase_		):
        pass





     self.assertEqual(find_labels(_lowercase				)	,     ["""labels"""]				)




   @require_tf
   def      __a						(   self      :    Any				):



     """simple docstring"""






     self.assertEqual(find_labels(_lowercase				)	,     ["""labels"""]				)
     self.assertEqual(find_labels(_lowercase				)	,     ["""labels""", """next_sentence_label"""]				)
     self.assertEqual(find_labels(_lowercase				)	,     ["""start_positions""", """end_positions"""]				)







     class __snake_case    (						lowerCamelCase_		):
        pass





     self.assertEqual(find_labels(_lowercase				)	,     ["""labels"""]				)




   @require_flax
   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     self.assertEqual(find_labels(_lowercase				)	,     []				)
     self.assertEqual(find_labels(_lowercase				)	,     []				)
     self.assertEqual(find_labels(_lowercase				)	,     []				)







     class __snake_case    (						lowerCamelCase_		):
        pass





     self.assertEqual(find_labels(_lowercase				)	,     []				)
