"""simple docstring"""




import logging
import os
import sys
from dataclasses import dataclass, field
from importlib import import_module
from typing import Dict, List, Optional, Tuple

import numpy as np
from seqeval.metrics import accuracy_score, fa_score, precision_score, recall_score
from torch import nn
from utils_ner import Split, TokenClassificationDataset, TokenClassificationTask

import transformers
from transformers import (
    AutoConfig,
    AutoModelForTokenClassification,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


__lowerCamelCase											=  logging.getLogger(__name__)
@dataclass
class     UpperCamelCase__:
						lowerCAmelCase__  :						str													=		field(
						    metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} )
						lowerCAmelCase__  :						Optional[str]													=		field(
						    default=__A		,						metadata={'help': 'Pretrained config name or path if not the same as model_name'} )
						lowerCAmelCase__  :						Optional[str]													=		field(
						    default='NER'		,						metadata={'help': 'Task type to fine tune in training (e.g. NER, POS, etc)'} )
						lowerCAmelCase__  :						Optional[str]													=		field(
						    default=__A		,						metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'} )
						lowerCAmelCase__  :						bool													=		field(default=__A		,						metadata={'help': 'Set this flag to use fast tokenization.'} )
						# If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
						# or just modify its tokenizer_config.json.
						lowerCAmelCase__  :						Optional[str]													=		field(
						    default=__A		,						metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}		,						)






@dataclass
class     UpperCamelCase__:
						lowerCAmelCase__  :						str													=		field(
						    metadata={'help': 'The input data dir. Should contain the .txt files for a CoNLL-2003-formatted task.'} )
						lowerCAmelCase__  :						Optional[str]													=		field(
						    default=__A		,						metadata={'help': 'Path to a file containing all labels. If not specified, CoNLL-2003 labels are used.'}		,						)
						lowerCAmelCase__  :						int													=		field(
						    default=128		,						metadata={
						        'help': (
						            'The maximum total input sequence length after tokenization. Sequences longer '
						            'than this will be truncated, sequences shorter will be padded.'
						        )
						    }		,						)
						lowerCAmelCase__  :						bool													=		field(
						    default=__A		,						metadata={'help': 'Overwrite the cached training and evaluation sets'} )






def   UpperCAmelCase					(	):






							"""simple docstring"""





							A__	     =							HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)				)
							if len(sys.argv				) == 2 and sys.argv[1].endswith('.json'				):
														# If we pass only one argument to the script and it's the path to a json file,
														# let's parse it to get our arguments.
														A__     ,  A__     ,  A__	     =							parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]				)				)
							else:
														A__     ,  A__     ,  A__	     =							parser.parse_args_into_dataclasses()

							if (
							    os.path.exists(training_args.output_dir				)
							    and os.listdir(training_args.output_dir				)
							    and training_args.do_train
							    and not training_args.overwrite_output_dir
							):
														raise ValueError(
														    F'''Output directory ({training_args.output_dir}) already exists and is not empty. Use'''
														    ' --overwrite_output_dir to overcome.'				)

							A__	     =							import_module('tasks'				)
							try:
														A__	     =							getattr(UpperCamelCase__       ,    model_args.task_type				)
														A__	     =							token_classification_task_clazz()
							except AttributeError:
														raise ValueError(
														    F'''Task {model_args.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. '''
														    F'''Available tasks classes are: {TokenClassificationTask.__subclasses__()}'''				)

							# Setup logging
							logging.basicConfig(
							    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'       ,    datefmt='%m/%d/%Y %H:%M:%S'       ,    level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN       ,    )
							logger.warning(
							    'Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s'       ,    training_args.local_rank       ,    training_args.device       ,    training_args.n_gpu       ,    bool(training_args.local_rank != -1				)       ,    training_args.fpaa       ,    )
							# Set the verbosity to info of the Transformers logger (on main process only):
							if is_main_process(training_args.local_rank				):
														transformers.utils.logging.set_verbosity_info()
														transformers.utils.logging.enable_default_handler()
														transformers.utils.logging.enable_explicit_format()
							logger.info('Training/evaluation parameters %s'       ,    UpperCamelCase__				)

							# Set seed
							set_seed(training_args.seed				)

							# Prepare CONLL-2003 task
							A__	     =							token_classification_task.get_labels(data_args.labels				)
							A__	     =							dict(enumerate(UpperCamelCase__				)				)
							A__	     =							len(UpperCamelCase__				)

							# Load pretrained model and tokenizer
							#
							# Distributed training:
							# The .from_pretrained methods guarantee that only one local process can concurrently
							# download model & vocab.

							A__	     =							AutoConfig.from_pretrained(
							    model_args.config_name if model_args.config_name else model_args.model_name_or_path       ,    num_labels=UpperCamelCase__       ,    idalabel=UpperCamelCase__       ,    labelaid={label: i for i, label in enumerate(UpperCamelCase__				)}       ,    cache_dir=model_args.cache_dir       ,    )
							A__	     =							AutoTokenizer.from_pretrained(
							    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path       ,    cache_dir=model_args.cache_dir       ,    use_fast=model_args.use_fast       ,    )
							A__	     =							AutoModelForTokenClassification.from_pretrained(
							    model_args.model_name_or_path       ,    from_tf=bool('.ckpt' in model_args.model_name_or_path				)       ,    config=UpperCamelCase__       ,    cache_dir=model_args.cache_dir       ,    )

							# Get datasets
							A__	     =							(
							    TokenClassificationDataset(
							        token_classification_task=UpperCamelCase__       ,    data_dir=data_args.data_dir       ,    tokenizer=UpperCamelCase__       ,    labels=UpperCamelCase__       ,    model_type=config.model_type       ,    max_seq_length=data_args.max_seq_length       ,    overwrite_cache=data_args.overwrite_cache       ,    mode=Split.train       ,    )
							    if training_args.do_train
							    else None
							)
							A__	     =							(
							    TokenClassificationDataset(
							        token_classification_task=UpperCamelCase__       ,    data_dir=data_args.data_dir       ,    tokenizer=UpperCamelCase__       ,    labels=UpperCamelCase__       ,    model_type=config.model_type       ,    max_seq_length=data_args.max_seq_length       ,    overwrite_cache=data_args.overwrite_cache       ,    mode=Split.dev       ,    )
							    if training_args.do_eval
							    else None
							)

							def align_predictions(UpperCamelCase__       ,    UpperCamelCase__				) -> Tuple[List[int], List[int]]:
														A__	     =							np.argmax(UpperCamelCase__       ,    axis=2				)

														A__     ,  A__	     =							preds.shape

														A__	     =							[[] for _ in range(UpperCamelCase__				)]
														A__	     =							[[] for _ in range(UpperCamelCase__				)]

														for i in range(UpperCamelCase__				):
																					for j in range(UpperCamelCase__				):
																												if label_ids[i, j] != nn.CrossEntropyLoss().ignore_index:
																																			out_label_list[i].append(label_map[label_ids[i][j]]				)
																																			preds_list[i].append(label_map[preds[i][j]]				)

														return preds_list, out_label_list

							def compute_metrics(UpperCamelCase__				) -> Dict:
														A__     ,  A__	     =							align_predictions(p.predictions       ,    p.label_ids				)
														return {
														    "accuracy_score": accuracy_score(UpperCamelCase__       ,    UpperCamelCase__				),
														    "precision": precision_score(UpperCamelCase__       ,    UpperCamelCase__				),
														    "recall": recall_score(UpperCamelCase__       ,    UpperCamelCase__				),
														    "f1": fa_score(UpperCamelCase__       ,    UpperCamelCase__				),
														}

							# Data collator
							A__	     =							DataCollatorWithPadding(UpperCamelCase__       ,    pad_to_multiple_of=8				) if training_args.fpaa else None

							# Initialize our Trainer
							A__	     =							Trainer(
							    model=UpperCamelCase__       ,    args=UpperCamelCase__       ,    train_dataset=UpperCamelCase__       ,    eval_dataset=UpperCamelCase__       ,    compute_metrics=UpperCamelCase__       ,    data_collator=UpperCamelCase__       ,    )

							# Training
							if training_args.do_train:
														trainer.train(
														    model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path				) else None				)
														trainer.save_model()
														# For convenience, we also re-save the tokenizer to the same directory,
														# so that you can share your model easily on huggingface.co/models =)
														if trainer.is_world_process_zero():
																					tokenizer.save_pretrained(training_args.output_dir				)

    # Evaluation
							A__	     =							{}
							if training_args.do_eval:
														logger.info('*** Evaluate ***'				)

														A__	     =							trainer.evaluate()

														A__	     =							os.path.join(training_args.output_dir       ,    'eval_results.txt'				)
														if trainer.is_world_process_zero():
																					with open(UpperCamelCase__       ,    'w'				) as writer:
																												logger.info('***** Eval results *****'				)
																												for key, value in result.items():
																																			logger.info('  %s = %s'       ,    UpperCamelCase__       ,    UpperCamelCase__				)
																																			writer.write('%s = %s\n' % (key, value)				)

																					results.update(UpperCamelCase__				)

    # Predict
							if training_args.do_predict:
														A__	     =							TokenClassificationDataset(
														    token_classification_task=UpperCamelCase__       ,    data_dir=data_args.data_dir       ,    tokenizer=UpperCamelCase__       ,    labels=UpperCamelCase__       ,    model_type=config.model_type       ,    max_seq_length=data_args.max_seq_length       ,    overwrite_cache=data_args.overwrite_cache       ,    mode=Split.test       ,    )

														A__     ,  A__     ,  A__	     =							trainer.predict(UpperCamelCase__				)
														A__     ,  A__	     =							align_predictions(UpperCamelCase__       ,    UpperCamelCase__				)

														A__	     =							os.path.join(training_args.output_dir       ,    'test_results.txt'				)
														if trainer.is_world_process_zero():
																					with open(UpperCamelCase__       ,    'w'				) as writer:
																												for key, value in metrics.items():
																																			logger.info('  %s = %s'       ,    UpperCamelCase__       ,    UpperCamelCase__				)
																																			writer.write('%s = %s\n' % (key, value)				)

        # Save predictions
														A__	     =							os.path.join(training_args.output_dir       ,    'test_predictions.txt'				)
														if trainer.is_world_process_zero():
																					with open(UpperCamelCase__       ,    'w'				) as writer:
																												with open(os.path.join(data_args.data_dir       ,    'test.txt'				)       ,    'r'				) as f:
																																			token_classification_task.write_predictions_to_file(UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__				)

							return results






def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





							main()


if __name__ == "__main__":
				main()






"""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__				)





