
'''simple docstring'''





import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


a__		: Union[str, Any]  							=							logging.getLogger(__name__)

require_version("pytorch_lightning>=1.0.4")

a__		: List[str]  							=							{
    "base": AutoModel,
    "sequence-classification": AutoModelForSequenceClassification,
    "question-answering": AutoModelForQuestionAnswering,
    "pretraining": AutoModelForPreTraining,
    "token-classification": AutoModelForTokenClassification,
    "language-modeling": AutoModelWithLMHead,
    "summarization": AutoModelForSeqaSeqLM,
    "translation": AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
a__		: List[str]  							=							{
    "linear": get_linear_schedule_with_warmup,
    "cosine": get_cosine_schedule_with_warmup,
    "cosine_w_restarts": get_cosine_with_hard_restarts_schedule_with_warmup,
    "polynomial": get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
a__		: Optional[Any]  							=							sorted(arg_to_scheduler.keys())
a__		: Tuple  							=							"{" + ", ".join(arg_to_scheduler_choices) + "}"


class 			UpperCamelCase__	(     pl.LightningModule):






 def __init__(      self	:Optional[Any]						,					_A	:argparse.Namespace						,					_A	:Optional[int]=None						,					_A	:List[Any]="base"						,					_A	:Tuple=None						,					_A	:List[Any]=None						,					_A	:Optional[Any]=None						,					**_A	:Optional[int]						,					)					->      Optional[Any]:







       '''simple docstring'''



       super().__init__()
       # TODO: move to self.save_hyperparameters()
       # self.save_hyperparameters()
       # can also expand arguments into trainer signature for easier reading

       self.save_hyperparameters(_A      )
       __A													=      0
       __A													=      Path(self.hparams.output_dir      )
       __A													=      self.hparams.cache_dir if self.hparams.cache_dir else None
       if config is None:
             __A													=      AutoConfig.from_pretrained(
                 self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path						,					**({'num_labels': num_labels} if num_labels is not None else {})						,					cache_dir=_A						,					**_A						,					)
       else:
             __A													=      config

       __A													=      ('encoder_layerdrop', 'decoder_layerdrop', 'dropout', 'attention_dropout')
       for p in extra_model_params:
             if getattr(self.hparams						,					_A						,					_A      ):
                   assert hasattr(self.config						,					_A      ), F'model config doesn\'t have a `{p}` attribute'
                   setattr(self.config						,					_A						,					getattr(self.hparams						,					_A      )      )

       if tokenizer is None:
             __A													=      AutoTokenizer.from_pretrained(
                 self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path						,					cache_dir=_A						,					)
       else:
             __A													=      tokenizer
       __A													=      MODEL_MODES[mode]
       if model is None:
             __A													=      self.model_type.from_pretrained(
                 self.hparams.model_name_or_path						,					from_tf=bool('.ckpt' in self.hparams.model_name_or_path      )						,					config=self.config						,					cache_dir=_A						,					)
       else:
             __A													=      model






 def 						lowercase_    (      self	:str						,					*_A	:str						,					**_A	:Dict      )					->      Union[str, Any]:







       '''simple docstring'''



       __A													=      self.model_type.from_pretrained(*_A						,					**_A      )






 def 						lowercase_    (      self	:Tuple      )					->      Optional[Any]:







       '''simple docstring'''



       __A													=      arg_to_scheduler[self.hparams.lr_scheduler]
       __A													=      get_schedule_func(
           self.opt						,					num_warmup_steps=self.hparams.warmup_steps						,					num_training_steps=self.total_steps()      )
       __A													=      {'scheduler': scheduler, 'interval': 'step', 'frequency': 1}
       return scheduler






 def 						lowercase_    (      self	:List[str]      )					->      Tuple:







       '''simple docstring'''



       __A													=      self.model
       __A													=      ['bias', 'LayerNorm.weight']
       __A													=      [
           {
               'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay      )],
               'weight_decay': self.hparams.weight_decay,
           },
           {
               'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay      )],
               'weight_decay': 0.0,
           },
       ]
       if self.hparams.adafactor:
             __A													=      Adafactor(
                 _A						,					lr=self.hparams.learning_rate						,					scale_parameter=_A						,					relative_step=_A      )

       else:
             __A													=      AdamW(
                 _A						,					lr=self.hparams.learning_rate						,					eps=self.hparams.adam_epsilon      )
       __A													=      optimizer

       __A													=      self.get_lr_scheduler()

       return [optimizer], [scheduler]






 def 						lowercase_    (      self	:Tuple						,					_A	:Tuple						,					_A	:str      )					->      Union[str, Any]:







       '''simple docstring'''



       return self.validation_step(_A						,					_A      )






 def 						lowercase_    (      self	:Union[str, Any]						,					_A	:Optional[int]      )					->      List[Any]:







       '''simple docstring'''



       return self.validation_end(_A      )






 def 						lowercase_    (      self	:Optional[int]      )					->      int:







       '''simple docstring'''



       __A													=      max(1						,					self.hparams.gpus      )  # TODO: consider num_tpu_cores
       __A													=      self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
       return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs






 def 						lowercase_    (      self	:int						,					_A	:Optional[int]      )					->      Optional[int]:







       '''simple docstring'''



       if mode == "test":
             __A													=      len(self.test_dataloader().dataset      )
       else:
             __A													=      self.get_dataloader('train'						,					self.hparams.train_batch_size						,					shuffle=_A      )
             __A													=      len(self.train_dataloader().dataset      )






 def 						lowercase_    (      self	:int						,					_A	:str						,					_A	:int						,					_A	:bool = False      )					->      Union[str, Any]:







       '''simple docstring'''



       raise NotImplementedError('You must implement this for your task'      )






 def 						lowercase_    (      self	:Optional[Any]      )					->      str:







       '''simple docstring'''



       return self.train_loader






 def 						lowercase_    (      self	:Optional[int]      )					->      Union[str, Any]:







       '''simple docstring'''



       return self.get_dataloader('dev'						,					self.hparams.eval_batch_size						,					shuffle=_A      )






 def 						lowercase_    (      self	:List[str]      )					->      Union[str, Any]:







       '''simple docstring'''



       return self.get_dataloader('test'						,					self.hparams.eval_batch_size						,					shuffle=_A      )






 def 						lowercase_    (      self	:str						,					_A	:Union[str, Any]      )					->      List[Any]:







       '''simple docstring'''



       return os.path.join(
           self.hparams.data_dir						,					'cached_{}_{}_{}'.format(
               _A						,					list(filter(_A						,					self.hparams.model_name_or_path.split('/'      )      )      ).pop()						,					str(self.hparams.max_seq_length      )						,					)						,					)






 @pl.utilities.rank_zero_only
 def 						lowercase_    (      self	:List[str]						,					_A	:Dict[str, Any]      )					->      None:







       '''simple docstring'''



       __A													=      self.output_dir.joinpath('best_tfmr'      )
       __A													=      self.step_count
       self.model.save_pretrained(_A      )
       self.tokenizer.save_pretrained(_A      )






 @staticmethod
 def 						lowercase_    (      _A	:Dict						,					_A	:Union[str, Any]      )					->      Optional[int]:







       '''simple docstring'''



       parser.add_argument(
           '--model_name_or_path'						,					default=_A						,					type=_A						,					required=_A						,					help='Path to pretrained model or model identifier from huggingface.co/models'						,					)
       parser.add_argument(
           '--config_name'						,					default=''						,					type=_A						,					help='Pretrained config name or path if not the same as model_name'      )
       parser.add_argument(
           '--tokenizer_name'						,					default=_A						,					type=_A						,					help='Pretrained tokenizer name or path if not the same as model_name'						,					)
       parser.add_argument(
           '--cache_dir'						,					default=''						,					type=_A						,					help='Where do you want to store the pre-trained models downloaded from huggingface.co'						,					)
       parser.add_argument(
           '--encoder_layerdrop'						,					type=_A						,					help='Encoder layer dropout probability (Optional). Goes into model.config'						,					)
       parser.add_argument(
           '--decoder_layerdrop'						,					type=_A						,					help='Decoder layer dropout probability (Optional). Goes into model.config'						,					)
       parser.add_argument(
           '--dropout'						,					type=_A						,					help='Dropout probability (Optional). Goes into model.config'						,					)
       parser.add_argument(
           '--attention_dropout'						,					type=_A						,					help='Attention dropout probability (Optional). Goes into model.config'						,					)
       parser.add_argument('--learning_rate'						,					default=5E-5						,					type=_A						,					help='The initial learning rate for Adam.'      )
       parser.add_argument(
           '--lr_scheduler'						,					default='linear'						,					choices=_A						,					metavar=_A						,					type=_A						,					help='Learning rate scheduler'						,					)
       parser.add_argument('--weight_decay'						,					default=0.0						,					type=_A						,					help='Weight decay if we apply some.'      )
       parser.add_argument('--adam_epsilon'						,					default=1E-8						,					type=_A						,					help='Epsilon for Adam optimizer.'      )
       parser.add_argument('--warmup_steps'						,					default=0						,					type=_A						,					help='Linear warmup over warmup_steps.'      )
       parser.add_argument('--num_workers'						,					default=4						,					type=_A						,					help='kwarg passed to DataLoader'      )
       parser.add_argument('--num_train_epochs'						,					dest='max_epochs'						,					default=3						,					type=_A      )
       parser.add_argument('--train_batch_size'						,					default=32						,					type=_A      )
       parser.add_argument('--eval_batch_size'						,					default=32						,					type=_A      )
       parser.add_argument('--adafactor'						,					action='store_true'      )


class 			UpperCamelCase__	(     pl.Callback):






 def 						lowercase_    (      self	:Tuple						,					_A	:Tuple						,					_A	:Dict      )					->      int:







       '''simple docstring'''



       __A													=      trainer.lr_schedulers[0]['scheduler']
       __A													=      {F'lr_group_{i}': lr for i, lr in enumerate(lr_scheduler.get_lr()      )}
       pl_module.logger.log_metrics(_A      )






 def 						lowercase_    (      self	:Dict						,					_A	:pl.Trainer						,					_A	:pl.LightningModule      )					->      str:







       '''simple docstring'''



       rank_zero_info('***** Validation results *****'      )
       __A													=      trainer.callback_metrics
       # Log results
       for key in sorted(_A      ):
             if key not in ["log", "progress_bar"]:
                   rank_zero_info('{} = {}\n'.format(_A						,					str(metrics[key]      )      )      )






 def 						lowercase_    (      self	:Union[str, Any]						,					_A	:pl.Trainer						,					_A	:pl.LightningModule      )					->      str:







       '''simple docstring'''



       rank_zero_info('***** Test results *****'      )
       __A													=      trainer.callback_metrics
       # Log and save results to file
       __A													=      os.path.join(pl_module.hparams.output_dir						,					'test_results.txt'      )
       with open(_A						,					'w'      ) as writer:
             for key in sorted(_A      ):
                   if key not in ["log", "progress_bar"]:
                         rank_zero_info('{} = {}\n'.format(_A						,					str(metrics[key]      )      )      )
                         writer.write('{} = {}\n'.format(_A						,					str(metrics[key]      )      )      )





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase						)->      None:







      """simple docstring"""
      #  To allow all pl args uncomment the following line
      #  parser = pl.Trainer.add_argparse_args(parser)
      parser.add_argument(
          '--output_dir'   ,	default=UpperCAmelCase   ,	type=UpperCAmelCase   ,	required=UpperCAmelCase   ,	help='The output directory where the model predictions and checkpoints will be written.'   ,	)
      parser.add_argument(
          '--fp16'   ,	action='store_true'   ,	help='Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit'   ,	)

      parser.add_argument(
          '--fp16_opt_level'   ,	type=UpperCAmelCase   ,	default='O2'   ,	help=(
              'For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\'].'
              'See details at https://nvidia.github.io/apex/amp.html'
          )   ,	)
      parser.add_argument('--n_tpu_cores'   ,	dest='tpu_cores'   ,	type=UpperCAmelCase						)
      parser.add_argument('--max_grad_norm'   ,	dest='gradient_clip_val'   ,	default=1.0   ,	type=UpperCAmelCase   ,	help='Max gradient norm'						)
      parser.add_argument('--do_train'   ,	action='store_true'   ,	help='Whether to run training.'						)
      parser.add_argument('--do_predict'   ,	action='store_true'   ,	help='Whether to run predictions on the test set.'						)
      parser.add_argument(
          '--gradient_accumulation_steps'   ,	dest='accumulate_grad_batches'   ,	type=UpperCAmelCase   ,	default=1   ,	help='Number of updates steps to accumulate before performing a backward/update pass.'   ,	)
      parser.add_argument('--seed'   ,	type=UpperCAmelCase   ,	default=4_2   ,	help='random seed for initialization'						)
      parser.add_argument(
          '--data_dir'   ,	default=UpperCAmelCase   ,	type=UpperCAmelCase   ,	required=UpperCAmelCase   ,	help='The input data dir. Should contain the training files for the CoNLL-2003 NER task.'   ,	)





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase=None   ,	UpperCAmelCase=True   ,	UpperCAmelCase=[]   ,	UpperCAmelCase=None   ,	UpperCAmelCase=None   ,	**UpperCAmelCase   ,	)->      Optional[Any]:







      """simple docstring"""
      pl.seed_everything(args.seed						)

      # init model
      __A													=      Path(model.hparams.output_dir						)
      odir.mkdir(exist_ok=UpperCAmelCase						)

      # add custom checkpoints
      if checkpoint_callback is None:
            __A													=      pl.callbacks.ModelCheckpoint(
                filepath=args.output_dir   ,	prefix='checkpoint'   ,	monitor='val_loss'   ,	mode='min'   ,	save_top_k=1						)
      if early_stopping_callback:
            extra_callbacks.append(UpperCAmelCase						)
      if logging_callback is None:
            __A													=      LoggingCallback()

      __A													=      {}

      # TODO: remove with PyTorch 1.6 since pl uses native amp
      if args.fpaa:
            __A													=      1_6
            __A													=      args.fpaa_opt_level

      if args.gpus > 1:
            __A													=      'ddp'

      __A													=      args.accumulate_grad_batches
      __A													=      extra_train_kwargs.get('accelerator'   ,	UpperCAmelCase						)
      __A													=      extra_train_kwargs.get('profiler'   ,	UpperCAmelCase						)

      __A													=      pl.Trainer.from_argparse_args(
          UpperCAmelCase   ,	weights_summary=UpperCAmelCase   ,	callbacks=[logging_callback] + extra_callbacks   ,	logger=UpperCAmelCase   ,	checkpoint_callback=UpperCAmelCase   ,	**UpperCAmelCase   ,	)

      if args.do_train:
            trainer.fit(UpperCAmelCase						)

      return trainer











import logging
from pathlib import Path
from typing import Any, List, Tuple

import yaml


# loading package files: https://stackoverflow.com/a/20885799
try:
						import importlib.resources as pkg_resources
except ImportError:
						# Try backported to PY<37 `importlib_resources`.
						import importlib_resources as pkg_resources

from . import resources


UpperCAmelCase_			      =  '''https://github.com/huggingface/datasets/tree/main/src/datasets/utils'''
UpperCAmelCase_			      =  f"""{BASE_REF_URL}/{__file__}"""
UpperCAmelCase_			      =  logging.getLogger(__name__)
def   UpperCAmelCase							(		A__     )							->					Tuple[Any, str]:
	_snake_case					:							Optional[int]					     =   pkg_resources.read_text(A__				,  A__     )
	return yaml.safe_load(A__     ), f'''{BASE_REF_URL}/resources/{resource}'''


UpperCAmelCase_      ,				UpperCAmelCase_			      =  load_yaml_resource('''readme_structure.yaml''')

UpperCAmelCase_			      =  [
    '''[Needs More Information]''',
    '''[More Information Needed]''',
    '''(https://github.com/huggingface/datasets/blob/main/CONTRIBUTING.md#how-to-contribute-to-the-dataset-cards)''',
]

# Dictionary representation of section/readme, error_list, warning_list
UpperCAmelCase_			      =  Tuple[dict, List[str], List[str]]





class 		__SCREAMING_SNAKE_CASE      :






				"""simple docstring"""

				def __init__(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = False      ):






					"""simple docstring"""

					_snake_case					:							Optional[Any]					     =   name
					_snake_case					:							str					     =   level
					_snake_case					:							Optional[Any]					     =   lines
					_snake_case					:							Any					     =   """"""
					_snake_case					:							int					     =   True
					_snake_case					:							Dict					     =   {}
					_snake_case					:							List[str]					     =   []
					_snake_case					:							Optional[Any]					     =   []
					if self.lines is not None:
						self.parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE__      )







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__ = False      ):






					"""simple docstring"""

					_snake_case					:							Dict					     =   """"""
					_snake_case					:							Dict					     =   []
					_snake_case					:							str					     =   False
					for line in self.lines:
						if line.strip(""" \n"""      ) == "":
							continue
						elif line.strip(""" \n"""      )[:3] == "```":
							_snake_case					:							Tuple					     =   not code_start
						elif line.split()[0] == self.level + "#" and not code_start:
							if current_sub_level != "":
								_snake_case					:							int					     =   Section(SCREAMING_SNAKE_CASE__						,	self.level + """#"""						,	SCREAMING_SNAKE_CASE__      )
								_snake_case					:							Optional[int]					     =   []
							else:
								if current_lines != []:
									self.text += "".join(SCREAMING_SNAKE_CASE__      ).strip()
									if self.text != "" and self.text not in FILLER_TEXT:
										_snake_case					:							Any					     =   False
									_snake_case					:							Tuple					     =   []

							_snake_case					:							Optional[Any]					     =   """ """.join(line.split()[1:]      ).strip(""" \n"""      )
						else:
							current_lines.append(SCREAMING_SNAKE_CASE__      )
					else:
						if current_sub_level != "":
							if current_sub_level in self.content:
								self.parsing_error_list.append(
								    f'''Multiple sections with the same heading `{current_sub_level}` have been found. Please keep only one of these sections.'''      )
							_snake_case					:							Union[str, Any]					     =   Section(SCREAMING_SNAKE_CASE__						,	self.level + """#"""						,	SCREAMING_SNAKE_CASE__      )
						else:
							if current_lines != []:
								self.text += "".join(SCREAMING_SNAKE_CASE__      ).strip()
								if self.text != "" and self.text not in FILLER_TEXT:
									_snake_case					:							Dict					     =   False

					if self.level == "" and not suppress_parsing_errors:
						if self.parsing_error_list != [] or self.parsing_warning_list != []:
							_snake_case					:							List[Any]					     =   """\n""".join("""-\t""" + x for x in self.parsing_error_list + self.parsing_warning_list      )
							_snake_case					:							Optional[Any]					     =   f'''The following issues were found while parsing the README at `{self.name}`:\n''' + errors
							raise ValueError(SCREAMING_SNAKE_CASE__      )







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__      ):






					"""simple docstring"""

					_snake_case					:							Union[str, Any]					     =   []
					_snake_case					:							Tuple					     =   []
					if structure["allow_empty"] is False:
						# If content is expected
						if self.is_empty_text and self.content == {}:
							# If no content is found, mention it in the error_list
							error_list.append(f'''Expected some content in section `{self.name}` but it is empty.'''      )

					if structure["allow_empty_text"] is False:
						# If some text is expected
						if self.is_empty_text:
							# If no text is found, mention it in the error_list
							error_list.append(
							    f'''Expected some text in section `{self.name}` but it is empty (text in subsections are ignored).'''      )
        # Subsections Validation
					if structure["subsections"] is not None:
						# If subsections are expected
						if self.content == {}:
							# If no subsections are present
							_snake_case					:							Optional[int]					     =   [subsection["""name"""] for subsection in structure["""subsections"""]]
							# Mention the expected values in the error_list
							error_list.append(
							    f'''Section `{self.name}` expected the following subsections: {", ".join(["`"+x+"`" for x in values]      )}. Found \'None\'.'''      )
						else:
							# If some subsections are present
							_snake_case					:							Tuple					     =   [subsection["""name"""] for subsection in structure["""subsections"""]]
							_snake_case					:							Dict					     =   False
							for idx, name in enumerate(SCREAMING_SNAKE_CASE__      ):
								if name not in self.content:
									# If the expected subsection is not present
									error_list.append(f'''Section `{self.name}` is missing subsection: `{name}`.'''      )
									_snake_case					:							int					     =   True
								else:
									# If the subsection is present, validate subsection, return the result
									# and concat the errors from subsection to section error_list

									# Skip sublevel validation if current level is `###`
									if self.level == "###":
										continue
									else:
										_snake_case     , _snake_case     , _snake_case					:							Tuple					     =   self.content[name].validate(
										    structure["""subsections"""][idx]      )
									error_list += subsec_error_list
									warning_list += subsec_warning_list

							if has_missing_subsections:  # we only allow to have extra subsections if all the other ones are here
								for name in self.content:
									if name not in structure_names:
										# If an extra subsection is present
										warning_list.append(
										    f'''`{self.name}` has an extra subsection: `{name}`. Skipping further validation checks for this subsection as expected structure is unknown.'''      )
					if error_list:
						# If there are errors, do not return the dictionary as it is invalid
						return {}, error_list, warning_list
					else:
						return self.to_dict(), error_list, warning_list







				def 		__lowerCamelCase(				self      ):






					"""simple docstring"""

					return {
					    "name": self.name,
					    "text": self.text,
					    "is_empty_text": self.is_empty_text,
					    "subsections": [value.to_dict() for value in self.content.values()],
					}





class 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):  # Level 0






				"""simple docstring"""

				def __init__(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = False      ):






					"""simple docstring"""

					super().__init__(name=SCREAMING_SNAKE_CASE__						,	level=""""""      )  # Not using lines here as we need to use a child class parse
					_snake_case					:							Optional[int]					     =   structure
					_snake_case					:							str					     =   -2
					_snake_case					:							Any					     =   0
					_snake_case					:							int					     =   lines
					if self.lines is not None:
						self.parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE__      )







				def 		__lowerCamelCase(				self      ):






					"""simple docstring"""

					if self.structure is None:
						_snake_case     , _snake_case     , _snake_case					:							List[Any]					     =   self._validate(SCREAMING_SNAKE_CASE__      )
					else:
						_snake_case     , _snake_case     , _snake_case					:							str					     =   self._validate(self.structure      )
					if error_list != [] or warning_list != []:
						_snake_case					:							List[Any]					     =   """\n""".join(["""-\t""" + x for x in error_list + warning_list]      )
						_snake_case					:							Any					     =   f'''The following issues were found for the README at `{self.name}`:\n''' + errors
						raise ValueError(SCREAMING_SNAKE_CASE__      )







				@classmethod
				def 		__lowerCamelCase(				cls						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = False      ):






					"""simple docstring"""

					with open(SCREAMING_SNAKE_CASE__						,	encoding="""utf-8"""      ) as f:
						_snake_case					:							List[str]					     =   f.readlines()
					return cls(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	suppress_parsing_errors=SCREAMING_SNAKE_CASE__      )







				@classmethod
				def 		__lowerCamelCase(				cls						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = "root"						,	SCREAMING_SNAKE_CASE__ = False      ):






					"""simple docstring"""

					_snake_case					:							Tuple					     =   string.split("""\n"""      )
					return cls(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	suppress_parsing_errors=SCREAMING_SNAKE_CASE__      )







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__ = False      ):






					"""simple docstring"""

					_snake_case					:							Optional[int]					     =   0

					for line in self.lines:
						self.yaml_tags_line_count += 1
						if line.strip(""" \n"""      ) == "---":
							self.tag_count += 1
							if self.tag_count == 2:
								break
						line_count += 1
					if self.tag_count == 2:
						_snake_case					:							Optional[int]					     =   self.lines[line_count + 1 :]  # Get the last + 1 th item.
					else:
						_snake_case					:							List[str]					     =   self.lines[self.tag_count :]
					super().parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE__      )







				def __str__(				self      ):






					"""simple docstring"""

					return str(self.to_dict()      )







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__      ):






					"""simple docstring"""

					_snake_case					:							str					     =   []
					_snake_case					:							str					     =   []
					if self.yaml_tags_line_count == 0:
						warning_list.append("""Empty YAML markers are present in the README."""      )
					elif self.tag_count == 0:
						warning_list.append("""No YAML markers are present in the README."""      )
					elif self.tag_count == 1:
						warning_list.append("""Only the start of YAML tags present in the README."""      )
					# Check how many first level sections are present.
					_snake_case					:							List[str]					     =   len(self.content.keys()      )
					if num_first_level_keys > 1:
						# If more than one, add to the error list, continue
						error_list.append(
						    f'''The README has several first-level headings: {", ".join(["`"+x+"`" for x in list(self.content.keys()      )]      )}. Only one heading is expected. Skipping further validation for this README.'''      )
					elif num_first_level_keys < 1:
						# If less than one, append error.
						error_list.append(
						    """The README has no first-level headings. One heading is expected. Skipping further validation for this README."""      )

					else:
						# If one exactly
						_snake_case					:							List[str]					     =   list(self.content.keys()      )[0]  # Get the key
						if start_key.startswith("""Dataset Card for"""      ):  # Check correct start
							# If the starting is correct, validate all the sections
							_snake_case     , _snake_case     , _snake_case					:							List[Any]					     =   self.content[start_key].validate(
							    readme_structure["""subsections"""][0]      )
							error_list += sec_error_list
							warning_list += sec_warning_list
						else:
							# If not found, append error
							error_list.append(
							    """No first-level heading starting with `Dataset Card for` found in README. Skipping further validation for this README."""      )
					if error_list:
						# If there are errors, do not return the dictionary as it is invalid
						return {}, error_list, warning_list
					else:
						return self.to_dict(), error_list, warning_list


if __name__ == "__main__":
						from argparse import ArgumentParser

						UpperCAmelCase_			      =  ArgumentParser(usage='''Validate the content (excluding YAML tags) of a README.md file.''')
						ap.add_argument('''readme_filepath''')
						UpperCAmelCase_			      =  ap.parse_args()
						UpperCAmelCase_			      =  Path(args.readme_filepath)
						UpperCAmelCase_			      =  ReadMe.from_readme(readme_filepath)





