


'''simple docstring'''







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


_SCREAMING_SNAKE_CASE       :   Union[str, Any]        = """https://github.com/huggingface/datasets/tree/main/src/datasets/utils"""
_SCREAMING_SNAKE_CASE       :   Any        = f"{BASE_REF_URL}/{__file__}"
_SCREAMING_SNAKE_CASE       :   Tuple        = logging.getLogger(__name__)



def 						_UpperCamelCase							( UpperCamelCase__		):






				"""simple docstring"""



				__magic_name__				:					Union[str, Any]						       =       pkg_resources.read_text(UpperCamelCase__     ,   UpperCamelCase__		)
				return yaml.safe_load(UpperCamelCase__		), F"""{BASE_REF_URL}/resources/{resource}"""


_SCREAMING_SNAKE_CASE       :   List[Any]        = load_yaml_resource("readme_structure.yaml")

_SCREAMING_SNAKE_CASE       :   Dict        = [
    """[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
_SCREAMING_SNAKE_CASE       :   Union[str, Any]        = Tuple[dict, List[str], List[str]]






class 		_snake_case    :






						'''simple docstring'''







						def __init__(  self:	Optional[Any]      ,							__UpperCamelCase:	Union[str, Any]      ,							__UpperCamelCase:	Any      ,							__UpperCamelCase:	Tuple = None      ,							__UpperCamelCase:	Tuple = False     )							->	Union[str, Any]:
										__magic_name__				:					int						       =       name
										__magic_name__				:					str						       =       level
										__magic_name__				:					Union[str, Any]						       =       lines
										__magic_name__				:					List[Any]						       =       ""
										__magic_name__				:					str						       =       True
										__magic_name__				:					str						       =       {}
										__magic_name__				:					List[Any]						       =       []
										__magic_name__				:					Tuple						       =       []
										if self.lines is not None:
														self.parse(suppress_parsing_errors=lowerCamelCase__     )







						def lowerCAmelCase__ (  self:	Any      ,							__UpperCamelCase:	Union[str, Any] = False     )							->	List[str]:
										__magic_name__				:					Optional[Any]						       =       ""
										__magic_name__				:					Union[str, Any]						       =       []
										__magic_name__				:					Any						       =       False
										for line in self.lines:
														if line.strip(" \n"     ) == "":
																		continue
														elif line.strip(" \n"     )[:3] == "```":
																		__magic_name__				:					str						       =       not code_start
														elif line.split()[0] == self.level + "#" and not code_start:
																		if current_sub_level != "":
																						__magic_name__				:					Any						       =       Section(lowerCamelCase__      ,							self.level + "#"      ,							lowerCamelCase__     )
																						__magic_name__				:					int						       =       []
																		else:
																						if current_lines != []:
																										self.text += "".join(lowerCamelCase__     ).strip()
																										if self.text != "" and self.text not in FILLER_TEXT:
																														__magic_name__				:					Union[str, Any]						       =       False
																										__magic_name__				:					List[Any]						       =       []

																		__magic_name__				:					int						       =       " ".join(line.split()[1:]     ).strip(" \n"     )
														else:
																		current_lines.append(lowerCamelCase__     )
										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."""     )
																		__magic_name__				:					List[str]						       =       Section(lowerCamelCase__      ,							self.level + "#"      ,							lowerCamelCase__     )
														else:
																		if current_lines != []:
																						self.text += "".join(lowerCamelCase__     ).strip()
																						if self.text != "" and self.text not in FILLER_TEXT:
																										__magic_name__				:					Any						       =       False

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







						def lowerCAmelCase__ (  self:	str      ,							__UpperCamelCase:	List[Any]     )							->	Optional[Any]:
										__magic_name__				:					str						       =       []
										__magic_name__				:					Optional[Any]						       =       []
										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
																		__magic_name__				:					Union[str, Any]						       =       [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
																		__magic_name__				:					List[str]						       =       [subsection["name"] for subsection in structure["subsections"]]
																		__magic_name__				:					Tuple						       =       False
																		for idx, name in enumerate(lowerCamelCase__     ):
																						if name not in self.content:
																										# If the expected subsection is not present
																										error_list.append(f"""Section `{self.name}` is missing subsection: `{name}`."""     )
																										__magic_name__				:					Optional[Any]						       =       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:
																														__magic_name__				:					Optional[int]						       =       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:	List[str]     )							->	str:
										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 		_snake_case    (				UpperCAmelCase__		):  # Level 0






						'''simple docstring'''







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







						def lowerCAmelCase__ (  self:	Any     )							->	List[Any]:
										if self.structure is None:
														__magic_name__				:					Tuple						       =       self._validate(lowerCamelCase__     )
										else:
														__magic_name__				:					int						       =       self._validate(self.structure     )
										if error_list != [] or warning_list != []:
														__magic_name__				:					Optional[Any]						       =       "\n".join(["-\t" + x for x in error_list + warning_list]     )
														__magic_name__				:					List[str]						       =       f"""The following issues were found for the README at `{self.name}`:\n""" + errors
														raise ValueError(lowerCamelCase__     )







						@classmethod
						def lowerCAmelCase__ (  cls:	List[str]      ,							__UpperCamelCase:	Union[str, Any]      ,							__UpperCamelCase:	Optional[int] = None      ,							__UpperCamelCase:	Union[str, Any] = False     )							->	Optional[Any]:
										with open(lowerCamelCase__      ,							encoding="utf-8"     ) as f:
														__magic_name__				:					int						       =       f.readlines()
										return cls(lowerCamelCase__      ,							lowerCamelCase__      ,							lowerCamelCase__      ,							suppress_parsing_errors=lowerCamelCase__     )







						@classmethod
						def lowerCAmelCase__ (  cls:	Dict      ,							__UpperCamelCase:	Optional[Any]      ,							__UpperCamelCase:	List[Any] = None      ,							__UpperCamelCase:	int = "root"      ,							__UpperCamelCase:	Dict = False     )							->	List[Any]:
										__magic_name__				:					Tuple						       =       string.split("\n"     )
										return cls(lowerCamelCase__      ,							lowerCamelCase__      ,							lowerCamelCase__      ,							suppress_parsing_errors=lowerCamelCase__     )







						def lowerCAmelCase__ (  self:	Any      ,							__UpperCamelCase:	Tuple = False     )							->	Any:
										# Skip Tags
										__magic_name__				:					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:
														__magic_name__				:					int						       =       self.lines[line_count + 1 :]  # Get the last + 1 th item.
										else:
														__magic_name__				:					Optional[Any]						       =       self.lines[self.tag_count :]
										super().parse(suppress_parsing_errors=lowerCamelCase__     )







						def __str__(  self:	Any     )							->	Dict:
										return str(self.to_dict()     )







						def lowerCAmelCase__ (  self:	Any      ,							__UpperCamelCase:	int     )							->	Optional[Any]:
										__magic_name__				:					Dict						       =       []
										__magic_name__				:					List[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.
										__magic_name__				:					Tuple						       =       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
														__magic_name__				:					Optional[Any]						       =       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
																		__magic_name__				:					Optional[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

		_SCREAMING_SNAKE_CASE       :   Tuple        = ArgumentParser(usage="Validate the content (excluding YAML tags) of a README.md file.")
		ap.add_argument("readme_filepath")
		_SCREAMING_SNAKE_CASE       :   int        = ap.parse_args()
		_SCREAMING_SNAKE_CASE       :   List[Any]        = Path(args.readme_filepath)
		_SCREAMING_SNAKE_CASE       :   Union[str, Any]        = ReadMe.from_readme(readme_filepath)



'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_SCREAMING_SNAKE_CASE       :   Any        = {
    "configuration_deberta_v2": ["DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP", "DebertaV2Config", "DebertaV2OnnxConfig"],
    "tokenization_deberta_v2": ["DebertaV2Tokenizer"],
}

try:
		if not is_tokenizers_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_SCREAMING_SNAKE_CASE       :   List[Any]        = ["DebertaV2TokenizerFast"]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_SCREAMING_SNAKE_CASE       :   int        = [
		    "TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TFDebertaV2ForMaskedLM",
		    "TFDebertaV2ForQuestionAnswering",
		    "TFDebertaV2ForSequenceClassification",
		    "TFDebertaV2ForTokenClassification",
		    "TFDebertaV2Model",
		    "TFDebertaV2PreTrainedModel",
		]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_SCREAMING_SNAKE_CASE       :   Union[str, Any]        = [
		    "DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "DebertaV2ForMaskedLM",
		    "DebertaV2ForMultipleChoice",
		    "DebertaV2ForQuestionAnswering",
		    "DebertaV2ForSequenceClassification",
		    "DebertaV2ForTokenClassification",
		    "DebertaV2Model",
		    "DebertaV2PreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_deberta_va import (
		    DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    DebertaVaConfig,
		    DebertaVaOnnxConfig,
		)
		from .tokenization_deberta_va import DebertaVaTokenizer

		try:
				if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_deberta_va_fast import DebertaVaTokenizerFast

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_deberta_va import (
				    TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFDebertaVaForMaskedLM,
				    TFDebertaVaForQuestionAnswering,
				    TFDebertaVaForSequenceClassification,
				    TFDebertaVaForTokenClassification,
				    TFDebertaVaModel,
				    TFDebertaVaPreTrainedModel,
				)

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_deberta_va import (
				    DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
				    DebertaVaForMaskedLM,
				    DebertaVaForMultipleChoice,
				    DebertaVaForQuestionAnswering,
				    DebertaVaForSequenceClassification,
				    DebertaVaForTokenClassification,
				    DebertaVaModel,
				    DebertaVaPreTrainedModel,
				)

else:
		import sys

		_SCREAMING_SNAKE_CASE       :   Dict        = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)