
import re
import tempfile
import unittest
from pathlib import Path

from datasets.utils.metadata import DatasetMetadata



def 						lowercase_			(   A__		)							->							str:
    """simple docstring"""

    snake_case      =					min(re.search("^ +" ,		A__		).end() if t.startswith(" "		) else 0 for t in string.splitlines()		)
    return "\n".join([line[indent_level:] for line in string.splitlines() if indent_level < len(A__		)]		)


_A  					= "\\n---\nlanguage:\n- zh\n- en\ntask_ids:\n- sentiment-classification\n---\n# Begin of markdown\n\nSome cool dataset card\n"

_A  					= "\\n---\n---\n# Begin of markdown\n\nSome cool dataset card\n"


_A  					= "\\n# Begin of markdown\n\nSome cool dataset card\n"







class      lowerCamelCase		(  unittest.TestCase  ):





     def 		UpperCAmelCase(self      :    Optional[int]   )						->						str:
         with tempfile.TemporaryDirectory() as tmp_dir:
             snake_case      =					Path(_A   ) / "README.md"
             with open(_A				,    "w+"   ) as readme_file:
                 readme_file.write(_A   )
             snake_case      =					DatasetMetadata.from_readme(_A   )
             self.assertDictEqual(_A				,    {"language": ["zh", "en"], "task_ids": ["sentiment-classification"]}   )

             with open(_A				,    "w+"   ) as readme_file:
                 readme_file.write(_A   )
             snake_case      =					DatasetMetadata.from_readme(_A   )
             self.assertDictEqual(_A				,    {}   )

             with open(_A				,    "w+"   ) as readme_file:
                 readme_file.write(_A   )
             snake_case      =					DatasetMetadata.from_readme(_A   )
             self.assertEqual(_A				,    {}   )





     def 		UpperCAmelCase(self      :    str   )						->						str:
         snake_case      =					_dedent(
             "\\n            annotations_creators:\n            - found\n            language_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - question-answering\n            task_ids:\n            - open-domain-qa\n            "   )
         assert DatasetMetadata.from_yaml_string(_A   )

         snake_case      =					_dedent(
             "\\n            annotations_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - question-answering\n            task_ids:\n            - open-domain-qa\n            task_ids:\n            - open-domain-qa\n            "   )
         with self.assertRaises(_A   ):
             DatasetMetadata.from_yaml_string(_A   )

         snake_case      =					_dedent(
             "\\n            annotations_creators:\n            - found\n            language_creators:\n            - found\n            language:\n            - en\n            license:\n            - unknown\n            multilinguality:\n            - monolingual\n            pretty_name: Test Dataset\n            size_categories:\n            - 10K<n<100K\n            source_datasets:\n            - extended|other-yahoo-webscope-l6\n            task_categories:\n            - text-classification\n            task_ids:\n            - multi-class-classification\n            paperswithcode_id:\n            - squad\n            configs:\n            - en\n            train-eval-index:\n            - config: en\n              task: text-classification\n              task_id: multi_class_classification\n              splits:\n                train_split: train\n                eval_split: test\n              col_mapping:\n                text: text\n                label: target\n              metrics:\n                - type: accuracy\n                  name: Accuracy\n            extra_gated_prompt: |\n              By clicking on “Access repository” below, you also agree to ImageNet Terms of Access:\n              [RESEARCHER_FULLNAME] (the \"Researcher\") has requested permission to use the ImageNet database (the \"Database\") at Princeton University and Stanford University. In exchange for such permission, Researcher hereby agrees to the following terms and conditions:\n              1. Researcher shall use the Database only for non-commercial research and educational purposes.\n            extra_gated_fields:\n              Company: text\n              Country: text\n              I agree to use this model for non-commerical use ONLY: checkbox\n            "   )
         assert DatasetMetadata.from_yaml_string(_A   )



from __future__ import annotations

import unittest

from transformers import MPNetConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers.models.mpnet.modeling_tf_mpnet import (
       TFMPNetForMaskedLM,
       TFMPNetForMultipleChoice,
       TFMPNetForQuestionAnswering,
       TFMPNetForSequenceClassification,
       TFMPNetForTokenClassification,
       TFMPNetModel,
   )







class      lowerCamelCase		:





     def __init__(self      :    Optional[Any]				,    _A      :    int				,    _A      :    Tuple=1_3				,    _A      :    List[str]=7				,    _A      :    Any=True				,    _A      :    Union[str, Any]=True				,    _A      :    Optional[Any]=False				,    _A      :    Tuple=True				,    _A      :    str=9_9				,    _A      :    Optional[Any]=6_4				,    _A      :    Optional[int]=2				,    _A      :    Union[str, Any]=4				,    _A      :    Any=6_4				,    _A      :    Any="gelu"				,    _A      :    str=0.1				,    _A      :    Union[str, Any]=0.1				,    _A      :    Optional[Any]=5_1_2				,    _A      :    int=1_6				,    _A      :    List[str]=2				,    _A      :    Optional[int]=0.02				,    _A      :    Optional[Any]=3				,    _A      :    List[str]=4				,    _A      :    int=None				,    )						->						List[Any]:
         snake_case      =					parent
         snake_case      =					batch_size
         snake_case      =					seq_length
         snake_case      =					is_training
         snake_case      =					use_input_mask
         snake_case      =					use_token_type_ids
         snake_case      =					use_labels
         snake_case      =					vocab_size
         snake_case      =					hidden_size
         snake_case      =					num_hidden_layers
         snake_case      =					num_attention_heads
         snake_case      =					intermediate_size
         snake_case      =					hidden_act
         snake_case      =					hidden_dropout_prob
         snake_case      =					attention_probs_dropout_prob
         snake_case      =					max_position_embeddings
         snake_case      =					type_vocab_size
         snake_case      =					type_sequence_label_size
         snake_case      =					initializer_range
         snake_case      =					num_labels
         snake_case      =					num_choices
         snake_case      =					scope





     def 		UpperCAmelCase(self      :    List[str]   )						->						Dict:
         snake_case      =					ids_tensor([self.batch_size, self.seq_length]				,    self.vocab_size   )

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

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

         snake_case      =					MPNetConfig(
             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				,    initializer_range=self.initializer_range				,    )
         return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels





     def 		UpperCAmelCase(self      :    Tuple				,    _A      :    str				,    _A      :    Dict				,    _A      :    Optional[Any]				,    _A      :    Optional[Any]				,    _A      :    List[str]				,    _A      :    int   )						->						List[Any]:
         snake_case      =					TFMPNetModel(config=_A   )
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         snake_case      =					model(_A   )
         snake_case      =					[input_ids, input_mask]
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.last_hidden_state.shape				,    (self.batch_size, self.seq_length, self.hidden_size)   )





     def 		UpperCAmelCase(self      :    int				,    _A      :    str				,    _A      :    Optional[Any]				,    _A      :    Optional[Any]				,    _A      :    Union[str, Any]				,    _A      :    Optional[Any]				,    _A      :    Any   )						->						int:
         snake_case      =					TFMPNetForMaskedLM(config=_A   )
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.vocab_size)   )





     def 		UpperCAmelCase(self      :    Dict				,    _A      :    Optional[int]				,    _A      :    int				,    _A      :    int				,    _A      :    List[str]				,    _A      :    Union[str, Any]				,    _A      :    Union[str, Any]   )						->						int:
         snake_case      =					TFMPNetForQuestionAnswering(config=_A   )
         snake_case      =					{
             "input_ids": input_ids,
             "attention_mask": input_mask,
         }
         snake_case      =					model(_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 		UpperCAmelCase(self      :    Optional[int]				,    _A      :    List[Any]				,    _A      :    Dict				,    _A      :    Dict				,    _A      :    Optional[int]				,    _A      :    str				,    _A      :    Optional[Any]   )						->						Dict:
         snake_case      =					self.num_labels
         snake_case      =					TFMPNetForSequenceClassification(_A   )
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_labels)   )





     def 		UpperCAmelCase(self      :    Union[str, Any]				,    _A      :    List[str]				,    _A      :    int				,    _A      :    Optional[int]				,    _A      :    Union[str, Any]				,    _A      :    Any				,    _A      :    int   )						->						Optional[Any]:
         snake_case      =					self.num_choices
         snake_case      =					TFMPNetForMultipleChoice(_A   )
         snake_case      =					tf.tile(tf.expand_dims(_A				,    1   )				,    (1, self.num_choices, 1)   )
         snake_case      =					tf.tile(tf.expand_dims(_A				,    1   )				,    (1, self.num_choices, 1)   )
         snake_case      =					{
             "input_ids": multiple_choice_inputs_ids,
             "attention_mask": multiple_choice_input_mask,
         }
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_choices)   )





     def 		UpperCAmelCase(self      :    List[Any]				,    _A      :    Union[str, Any]				,    _A      :    Dict				,    _A      :    Optional[Any]				,    _A      :    int				,    _A      :    int				,    _A      :    Tuple   )						->						Tuple:
         snake_case      =					self.num_labels
         snake_case      =					TFMPNetForTokenClassification(_A   )
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.num_labels)   )





     def 		UpperCAmelCase(self      :    List[Any]   )						->						List[str]:
         snake_case      =					self.prepare_config_and_inputs()
         ((snake_case)     ,							(snake_case)     ,							(snake_case)     ,							(snake_case)     ,							(snake_case)     ,							(snake_case))      =					config_and_inputs
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         return config, inputs_dict







@require_tf
class      lowerCamelCase		(  A_							, A_							, unittest.TestCase  ):
     UpperCAmelCase__				:							List[Any]           =		(
         (
             TFMPNetForMaskedLM,
             TFMPNetForMultipleChoice,
             TFMPNetForQuestionAnswering,
             TFMPNetForSequenceClassification,
             TFMPNetForTokenClassification,
             TFMPNetModel,
         )
         if is_tf_available()
         else ()
     )
     UpperCAmelCase__				:							Optional[int]           =		(
         {
             "feature-extraction": TFMPNetModel,
             "fill-mask": TFMPNetForMaskedLM,
             "question-answering": TFMPNetForQuestionAnswering,
             "text-classification": TFMPNetForSequenceClassification,
             "token-classification": TFMPNetForTokenClassification,
             "zero-shot": TFMPNetForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     UpperCAmelCase__				:							int           =		False
     UpperCAmelCase__				:							str           =		False





     def 		UpperCAmelCase(self      :    List[Any]   )						->						str:
         snake_case      =					TFMPNetModelTester(self   )
         snake_case      =					ConfigTester(self				,    config_class=_A				,    hidden_size=3_7   )





     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						int:
         self.config_tester.run_common_tests()





     def 		UpperCAmelCase(self      :    Optional[int]   )						->						str:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_model(*_A   )





     def 		UpperCAmelCase(self      :    List[str]   )						->						List[str]:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_masked_lm(*_A   )





     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						str:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_question_answering(*_A   )





     def 		UpperCAmelCase(self      :    Dict   )						->						Tuple:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_sequence_classification(*_A   )





     def 		UpperCAmelCase(self      :    int   )						->						List[Any]:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_multiple_choice(*_A   )





     def 		UpperCAmelCase(self      :    Union[str, Any]   )						->						int:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_token_classification(*_A   )





     @slow
     def 		UpperCAmelCase(self      :    Optional[int]   )						->						Union[str, Any]:
         for model_name in ["microsoft/mpnet-base"]:
             snake_case      =					TFMPNetModel.from_pretrained(_A   )
             self.assertIsNotNone(_A   )







@require_tf
class      lowerCamelCase		(  unittest.TestCase  ):





     @slow
     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						List[Any]:
         snake_case      =					TFMPNetModel.from_pretrained("microsoft/mpnet-base"   )
         snake_case      =					tf.constant([[0, 1, 2, 3, 4, 5]]   )
         snake_case      =					model(_A   )[0]

         snake_case      =					[1, 6, 7_6_8]
         self.assertEqual(output.shape				,    _A   )

         snake_case      =					tf.constant(
             [
                 [
                     [-0.1_06_71_72, 0.08_21_64_73, 0.0_02_45_43],
                     [-0.03_46_58_79, 0.8_35_41_18, -0.03_25_22_88],
                     [-0.06_56_94_76, -0.12_42_41_11, -0.0_49_44_36],
                 ]
             ]   )
         tf.debugging.assert_near(output[:, :3, :3]				,    _A				,    atol=1E-4   )

