"""simple docstring"""




import inspect
import math
import tempfile
import unittest

import numpy as np

from transformers import ViTMAEConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 ViTMAEForPreTraining, ViTMAEModel
				from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import ViTImageProcessor
class     UpperCamelCase__:





						def __init__(       self		,__UpperCAmelCase		,__UpperCAmelCase=13		,__UpperCAmelCase=30		,__UpperCAmelCase=2		,__UpperCAmelCase=3		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=32		,__UpperCAmelCase=5		,__UpperCAmelCase=4		,__UpperCAmelCase=37		,__UpperCAmelCase="gelu"		,__UpperCAmelCase=0.1		,__UpperCAmelCase=0.1		,__UpperCAmelCase=10		,__UpperCAmelCase=0.0_2		,__UpperCAmelCase=3		,__UpperCAmelCase=0.6		,__UpperCAmelCase=None		,)					->				Optional[int]:
													A__	     =							parent
													A__	     =							batch_size
													A__	     =							image_size
													A__	     =							patch_size
													A__	     =							num_channels
													A__	     =							is_training
													A__	     =							use_labels
													A__	     =							hidden_size
													A__	     =							num_hidden_layers
													A__	     =							num_attention_heads
													A__	     =							intermediate_size
													A__	     =							hidden_act
													A__	     =							hidden_dropout_prob
													A__	     =							attention_probs_dropout_prob
													A__	     =							type_sequence_label_size
													A__	     =							initializer_range
													A__	     =							mask_ratio
													A__	     =							scope

													# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
													# (we add 1 for the [CLS] token)
													A__	     =							(image_size // patch_size) ** 2
													A__	     =							int(math.ceil((1 - mask_ratio) * (num_patches + 1)     )     )





						def 				snake_case__	(       self     )					->				Dict:
													A__	     =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

													A__	     =							self.get_config()

													return config, pixel_values, labels





						def 				snake_case__	(       self     )					->				int:
													return ViTMAEConfig(
													    image_size=self.image_size		,patch_size=self.patch_size		,num_channels=self.num_channels		,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		,is_decoder=__UpperCAmelCase		,initializer_range=self.initializer_range		,mask_ratio=self.mask_ratio		,)





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Dict:
													A__	     =							ViTMAEModel(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(__UpperCAmelCase     )
													self.parent.assertEqual(result.last_hidden_state.shape		,(self.batch_size, self.seq_length, self.hidden_size)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Dict:
													A__	     =							ViTMAEForPreTraining(__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(__UpperCAmelCase     )
													A__	     =							(self.image_size // self.patch_size) ** 2
													A__	     =							self.patch_size**2 * self.num_channels
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, num_patches, expected_num_channels)     )

													# test greyscale images
													A__	     =							1
													A__	     =							ViTMAEForPreTraining(__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]     )
													A__	     =							model(__UpperCAmelCase     )
													A__	     =							self.patch_size**2
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, num_patches, expected_num_channels)     )





						def 				snake_case__	(       self     )					->				List[str]:
													A__	     =							self.prepare_config_and_inputs()
													A__     ,  A__     ,  A__	     =							config_and_inputs
													A__	     =							{'pixel_values': pixel_values}
													return config, inputs_dict






@require_torch
class     UpperCamelCase__(			__A		,						__A		,						unittest.TestCase ):
						lowerCAmelCase__  :						str													=		(ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
						lowerCAmelCase__  :						Dict													=		{'feature-extraction': ViTMAEModel} if is_torch_available() else {}

						lowerCAmelCase__  :						List[str]													=		False
						lowerCAmelCase__  :						List[Any]													=		False
						lowerCAmelCase__  :						Optional[Any]													=		False
						lowerCAmelCase__  :						Optional[Any]													=		False





						def 				snake_case__	(       self     )					->				Any:
													A__	     =							ViTMAEModelTester(self     )
													A__	     =							ConfigTester(self		,config_class=__UpperCAmelCase		,has_text_modality=__UpperCAmelCase		,hidden_size=37     )





						def 				snake_case__	(       self     )					->				Dict:
													self.config_tester.run_common_tests()





						@unittest.skip(reason='ViTMAE does not use inputs_embeds'     )
						def 				snake_case__	(       self     )					->				Tuple:
													pass





						def 				snake_case__	(       self     )					->				Dict:
													A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()

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





						def 				snake_case__	(       self     )					->				List[Any]:
													A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()

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

																				A__	     =							['pixel_values']
																				self.assertListEqual(arg_names[:1]		,__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				int:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				int:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_pretraining(*__UpperCAmelCase     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[Any]:
													# make masks reproducible
													np.random.seed(2     )

													A__	     =							int((pt_model.config.image_size // pt_model.config.patch_size) ** 2     )
													A__	     =							np.random.uniform(size=(self.model_tester.batch_size, num_patches)     )
													A__	     =							torch.from_numpy(__UpperCAmelCase     )

													# Add `noise` argument.
													# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
													A__	     =							pt_noise

													super().check_pt_tf_models(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Dict:
													A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A__	     =							model_class(__UpperCAmelCase     )
																				model.to(__UpperCAmelCase     )
																				model.eval()
																				# make random mask reproducible
																				torch.manual_seed(2     )
																				with torch.no_grad():
																											A__	     =							model(**self._prepare_for_class(__UpperCAmelCase		,__UpperCAmelCase     )     )

																				A__	     =							outputs[0].cpu().numpy()
																				A__	     =							0

																				with tempfile.TemporaryDirectory() as tmpdirname:
																											model.save_pretrained(__UpperCAmelCase     )
																											A__	     =							model_class.from_pretrained(__UpperCAmelCase     )
																											model.to(__UpperCAmelCase     )
																											# make random mask reproducible
																											torch.manual_seed(2     )
																											with torch.no_grad():
																																		A__	     =							model(**self._prepare_for_class(__UpperCAmelCase		,__UpperCAmelCase     )     )

																											# Make sure we don't have nans
																											A__	     =							after_outputs[0].cpu().numpy()
																											A__	     =							0
																											A__	     =							np.amax(np.abs(out_a - out_a     )     )
																											self.assertLessEqual(__UpperCAmelCase		,1e-5     )





						@unittest.skip(
						    reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.'     )
						def 				snake_case__	(       self     )					->				List[str]:
													pass





						@unittest.skip(
						    reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.'     )
						def 				snake_case__	(       self     )					->				List[str]:
													pass





						@unittest.skip(
						    reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.'     )
						def 				snake_case__	(       self     )					->				Union[str, Any]:
													pass





						@unittest.skip(reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'     )
						def 				snake_case__	(       self     )					->				str:
													pass





						@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'     )
						def 				snake_case__	(       self     )					->				Any:
													pass





						@slow
						def 				snake_case__	(       self     )					->				str:
													for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__	     =							ViTMAEModel.from_pretrained(__UpperCAmelCase     )
																				self.assertIsNotNone(__UpperCAmelCase     )






def   UpperCAmelCase					(	):






							"""simple docstring"""





							A__	     =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
							return image


@require_torch
@require_vision
class     UpperCamelCase__(			unittest.TestCase ):





						@cached_property
						def 				snake_case__	(       self     )					->				Optional[int]:
													return ViTImageProcessor.from_pretrained('facebook/vit-mae-base'     ) if is_vision_available() else None





						@slow
						def 				snake_case__	(       self     )					->				str:
													# make random mask reproducible across the PT and TF model
													np.random.seed(2     )

													A__	     =							ViTMAEForPreTraining.from_pretrained('facebook/vit-mae-base'     ).to(__UpperCAmelCase     )

													A__	     =							self.default_image_processor
													A__	     =							prepare_img()
													A__	     =							image_processor(images=__UpperCAmelCase		,return_tensors='pt'     ).to(__UpperCAmelCase     )

													# prepare a noise vector that will be also used for testing the TF model
													# (this way we can ensure that the PT and TF models operate on the same inputs)
													A__	     =							ViTMAEConfig()
													A__	     =							int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2     )
													A__	     =							np.random.uniform(size=(1, num_patches)     )

													# forward pass
													with torch.no_grad():
																				A__	     =							model(**__UpperCAmelCase		,noise=torch.from_numpy(__UpperCAmelCase     ).to(device=__UpperCAmelCase     )     )

													# verify the logits
													A__	     =							torch.Size((1, 1_96, 7_68)     )
													self.assertEqual(outputs.logits.shape		,__UpperCAmelCase     )

													A__	     =							torch.tensor(
													    [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]]     )

													self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]		,expected_slice.to(__UpperCAmelCase     )		,atol=1e-4     )     )






"""simple docstring"""




import re
import tempfile
from pathlib import Path

import pytest
import yaml

from datasets.utils.readme import ReadMe


# @pytest.fixture
# def example_yaml_structure():

__lowerCamelCase											=  yaml.safe_load(
    "\\nname: \"\"\nallow_empty: false\nallow_empty_text: true\nsubsections:\n  - name: \"Dataset Card for X\" # First-level markdown heading\n    allow_empty: false\n    allow_empty_text: true\n    subsections:\n      - name: \"Table of Contents\"\n        allow_empty: false\n        allow_empty_text: false\n        subsections: null\n      - name: \"Dataset Description\"\n        allow_empty: false\n        allow_empty_text: false\n        subsections:\n          - name: \"Dataset Summary\"\n            allow_empty: false\n            allow_empty_text: false\n            subsections: null\n          - name: \"Supported Tasks and Leaderboards\"\n            allow_empty: true\n            allow_empty_text: true\n            subsections: null\n          - name: Languages\n            allow_empty: false\n            allow_empty_text: true\n            subsections: null\n"
)


__lowerCamelCase											=  {
    "name": "root",
    "text": "",
    "is_empty_text": True,
    "subsections": [
        {
            "name": "Dataset Card for My Dataset",
            "text": "",
            "is_empty_text": True,
            "subsections": [
                {"name": "Table of Contents", "text": "Some text here.", "is_empty_text": False, "subsections": []},
                {
                    "name": "Dataset Description",
                    "text": "Some text here.",
                    "is_empty_text": False,
                    "subsections": [
                        {
                            "name": "Dataset Summary",
                            "text": "Some text here.",
                            "is_empty_text": False,
                            "subsections": [],
                        },
                        {
                            "name": "Supported Tasks and Leaderboards",
                            "text": "",
                            "is_empty_text": True,
                            "subsections": [],
                        },
                        {"name": "Languages", "text": "Language Text", "is_empty_text": False, "subsections": []},
                    ],
                },
            ],
        }
    ],
}


__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"


__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n#### Extra Ignored Subsection\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

__lowerCamelCase											=  {
    "name": "root",
    "text": "",
    "is_empty_text": True,
    "subsections": [
        {
            "name": "Dataset Card for My Dataset",
            "text": "",
            "is_empty_text": True,
            "subsections": [
                {"name": "Table of Contents", "text": "Some text here.", "is_empty_text": False, "subsections": []},
                {
                    "name": "Dataset Description",
                    "text": "Some text here.",
                    "is_empty_text": False,
                    "subsections": [
                        {
                            "name": "Dataset Summary",
                            "text": "Some text here.",
                            "is_empty_text": False,
                            "subsections": [
                                {
                                    "name": "Extra Ignored Subsection",
                                    "text": "",
                                    "is_empty_text": True,
                                    "subsections": [],
                                }
                            ],
                        },
                        {
                            "name": "Supported Tasks and Leaderboards",
                            "text": "",
                            "is_empty_text": True,
                            "subsections": [],
                        },
                        {"name": "Languages", "text": "Language Text", "is_empty_text": False, "subsections": []},
                    ],
                },
            ],
        }
    ],
}

__lowerCamelCase											=  "\\n---\n---\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

__lowerCamelCase											=  (
    "The following issues were found for the README at `{path}`:\n-\tEmpty YAML markers are present in the README."
)

__lowerCamelCase											=  "\\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

__lowerCamelCase											=  (
    "The following issues were found for the README at `{path}`:\n-\tNo YAML markers are present in the README."
)

__lowerCamelCase											=  "\\n---\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tOnly the start of YAML tags present in the README."

__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"
__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Dataset Summary` but it is empty.\n-\tExpected some text in section `Dataset Summary` but it is empty (text in subsections are ignored)."


__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n"
__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Dataset Card for My Dataset` but it is empty.\n-\tSection `Dataset Card for My Dataset` expected the following subsections: `Table of Contents`, `Dataset Description`. Found 'None'."

__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Languages\nLanguage Text\n"

__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tSection `Dataset Description` is missing subsection: `Supported Tasks and Leaderboards`."


__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\n"

__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Languages` but it is empty."

__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"
__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tThe README has no first-level headings. One heading is expected. Skipping further validation for this README."

__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n# Dataset Card My Dataset\n"

__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tThe README has several first-level headings: `Dataset Card for My Dataset`, `Dataset Card My Dataset`. Only one heading is expected. Skipping further validation for this README."

__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tNo first-level heading starting with `Dataset Card for` found in README. Skipping further validation for this README."

__lowerCamelCase											=  ""

__lowerCamelCase											=  "The following issues were found for the README at `{path}`:\n-\tThe README has no first-level headings. One heading is expected. Skipping further validation for this README.\n-\tNo YAML markers are present in the README."

__lowerCamelCase											=  "\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n"

__lowerCamelCase											=  "The following issues were found while parsing the README at `{path}`:\n-\tMultiple sections with the same heading `Dataset Card for My Dataset` have been found. Please keep only one of these sections."






@pytest.mark.parametrize(
    'readme_md, expected_dict'       ,    [
        (README_CORRECT, CORRECT_DICT),
        (README_CORRECT_FOUR_LEVEL, CORRECT_DICT_FOUR_LEVEL),
    ]       ,    )
def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							assert ReadMe.from_string(UpperCamelCase__       ,    UpperCamelCase__				).to_dict() == expected_dict






@pytest.mark.parametrize(
    'readme_md, expected_error'       ,    [
        (README_NO_YAML, EXPECTED_ERROR_README_NO_YAML),
        (README_EMPTY_YAML, EXPECTED_ERROR_README_EMPTY_YAML),
        (README_INCORRECT_YAML, EXPECTED_ERROR_README_INCORRECT_YAML),
        (README_EMPTY, EXPECTED_ERROR_README_EMPTY),
        (README_NONE_SUBSECTION, EXPECTED_ERROR_README_NONE_SUBSECTION),
        (README_MISSING_FIRST_LEVEL, EXPECTED_ERROR_README_MISSING_FIRST_LEVEL),
        (README_MISSING_SUBSECTION, EXPECTED_ERROR_README_MISSING_SUBSECTION),
        (README_MISSING_TEXT, EXPECTED_ERROR_README_MISSING_TEXT),
        (README_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_WRONG_FIRST_LEVEL),
        (README_MULTIPLE_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_MULTIPLE_WRONG_FIRST_LEVEL),
        (README_MISSING_CONTENT, EXPECTED_ERROR_README_MISSING_CONTENT),
    ]       ,    )
def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							with pytest.raises(UpperCamelCase__       ,    match=re.escape(expected_error.format(path='root'				)				)				):
														A__	     =							ReadMe.from_string(UpperCamelCase__       ,    UpperCamelCase__				)
														readme.validate()






@pytest.mark.parametrize(
    'readme_md, expected_error'       ,    [
        (README_MULTIPLE_SAME_HEADING_1, EXPECTED_ERROR_README_MULTIPLE_SAME_HEADING_1),
    ]       ,    )
def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							with pytest.raises(UpperCamelCase__       ,    match=re.escape(expected_error.format(path='root'				)				)				):
														ReadMe.from_string(UpperCamelCase__       ,    UpperCamelCase__				)






@pytest.mark.parametrize(
    'readme_md,'       ,    [
        (README_MULTIPLE_SAME_HEADING_1),
    ]       ,    )
def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





							ReadMe.from_string(UpperCamelCase__       ,    UpperCamelCase__       ,    suppress_parsing_errors=UpperCamelCase__				)






@pytest.mark.parametrize(
    'readme_md, expected_dict'       ,    [
        (README_CORRECT, CORRECT_DICT),
        (README_CORRECT_FOUR_LEVEL, CORRECT_DICT_FOUR_LEVEL),
    ]       ,    )
def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							with tempfile.TemporaryDirectory() as tmp_dir:
														A__	     =							Path(UpperCamelCase__				) / 'README.md'
														with open(UpperCamelCase__       ,    'w+'				) as readme_file:
																					readme_file.write(UpperCamelCase__				)
														A__	     =							ReadMe.from_readme(UpperCamelCase__       ,    UpperCamelCase__				).to_dict()
														assert out["name"] == path
														assert out["text"] == ""
														assert out["is_empty_text"]
														assert out["subsections"] == expected_dict["subsections"]






@pytest.mark.parametrize(
    'readme_md, expected_error'       ,    [
        (README_NO_YAML, EXPECTED_ERROR_README_NO_YAML),
        (README_EMPTY_YAML, EXPECTED_ERROR_README_EMPTY_YAML),
        (README_INCORRECT_YAML, EXPECTED_ERROR_README_INCORRECT_YAML),
        (README_EMPTY, EXPECTED_ERROR_README_EMPTY),
        (README_NONE_SUBSECTION, EXPECTED_ERROR_README_NONE_SUBSECTION),
        (README_MISSING_FIRST_LEVEL, EXPECTED_ERROR_README_MISSING_FIRST_LEVEL),
        (README_MISSING_SUBSECTION, EXPECTED_ERROR_README_MISSING_SUBSECTION),
        (README_MISSING_TEXT, EXPECTED_ERROR_README_MISSING_TEXT),
        (README_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_WRONG_FIRST_LEVEL),
        (README_MULTIPLE_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_MULTIPLE_WRONG_FIRST_LEVEL),
        (README_MISSING_CONTENT, EXPECTED_ERROR_README_MISSING_CONTENT),
    ]       ,    )
def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							with tempfile.TemporaryDirectory() as tmp_dir:
														A__	     =							Path(UpperCamelCase__				) / 'README.md'
														with open(UpperCamelCase__       ,    'w+'				) as readme_file:
																					readme_file.write(UpperCamelCase__				)
														A__	     =							expected_error.format(path=UpperCamelCase__				)
														with pytest.raises(UpperCamelCase__       ,    match=re.escape(UpperCamelCase__				)				):
																					A__	     =							ReadMe.from_readme(UpperCamelCase__       ,    UpperCamelCase__				)
																					readme.validate()






@pytest.mark.parametrize(
    'readme_md, expected_error'       ,    [
        (README_MULTIPLE_SAME_HEADING_1, EXPECTED_ERROR_README_MULTIPLE_SAME_HEADING_1),
    ]       ,    )
def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							with tempfile.TemporaryDirectory() as tmp_dir:
														A__	     =							Path(UpperCamelCase__				) / 'README.md'
														with open(UpperCamelCase__       ,    'w+'				) as readme_file:
																					readme_file.write(UpperCamelCase__				)
														A__	     =							expected_error.format(path=UpperCamelCase__				)
														with pytest.raises(UpperCamelCase__       ,    match=re.escape(UpperCamelCase__				)				):
																					ReadMe.from_readme(UpperCamelCase__       ,    UpperCamelCase__				)






@pytest.mark.parametrize(
    'readme_md,'       ,    [
        (README_MULTIPLE_SAME_HEADING_1),
    ]       ,    )
def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





							with tempfile.TemporaryDirectory() as tmp_dir:
														A__	     =							Path(UpperCamelCase__				) / 'README.md'
														with open(UpperCamelCase__       ,    'w+'				) as readme_file:
																					readme_file.write(UpperCamelCase__				)
														ReadMe.from_readme(UpperCamelCase__       ,    UpperCamelCase__       ,    suppress_parsing_errors=UpperCamelCase__				)





