



'''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


_UpperCamelCase									=      '''https://github.com/huggingface/datasets/tree/main/src/datasets/utils'''
_UpperCamelCase									=      F'{BASE_REF_URL}/{__file__}'
_UpperCamelCase									=      logging.getLogger(__name__)


def 	lowercase_						( lowerCAmelCase__						:	str			):

			"""simple docstring"""





			__UpperCAmelCase :   int    					=  pkg_resources.read_text(lowerCAmelCase__      ,				lowerCAmelCase__			)
			return yaml.safe_load(lowerCAmelCase__			), 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 _A	:





		def __init__(  self			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase = None			,							__UpperCAmelCase = False					)							->  Optional[int]:

					'''simple docstring'''
					__UpperCAmelCase :   str    					=  name
					__UpperCAmelCase :   Optional[int]    					=  level
					__UpperCAmelCase :   Union[str, Any]    					=  lines
					__UpperCAmelCase :   Optional[int]    					=  """"""
					__UpperCAmelCase :   List[str]    					=  True
					__UpperCAmelCase :   int    					=  {}
					__UpperCAmelCase :   Tuple    					=  []
					__UpperCAmelCase :   int    					=  []
					if self.lines is not None:
								self.parse(suppress_parsing_errors=__UpperCAmelCase					)





		def 				__A							(  self			,							__UpperCAmelCase = False					)							->  Dict:

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

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

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





		def 				__A							(  self			,							__UpperCAmelCase					)							->  ReadmeValidatorOutput:

					'''simple docstring'''
					__UpperCAmelCase :   Optional[Any]    					=  []
					__UpperCAmelCase :   int    					=  []
					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
											__UpperCAmelCase :   Optional[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
											__UpperCAmelCase :   Any    					=  [subsection["""name"""] for subsection in structure["""subsections"""]]
											__UpperCAmelCase :   List[str]    					=  False
											for idx, name in enumerate(__UpperCAmelCase					):
														if name not in self.content:
																	# If the expected subsection is not present
																	error_list.append(f'Section `{self.name}` is missing subsection: `{name}`.'					)
																	__UpperCAmelCase :   str    					=  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:
																				__UpperCAmelCase					,	__UpperCAmelCase					,	__UpperCAmelCase :   Any    					=  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 				__A							(  self					)							->  dict:

					'''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 _A	(     __SCREAMING_SNAKE_CASE     ):  # Level 0





		def __init__(  self			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase = None			,							__UpperCAmelCase = False					)							->  int:

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





		def 				__A							(  self					)							->  Dict:

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





		@classmethod
		def 				__A							(  cls			,							__UpperCAmelCase			,							__UpperCAmelCase = None			,							__UpperCAmelCase = False					)							->  Union[str, Any]:

					'''simple docstring'''
					with open(__UpperCAmelCase			,							encoding="""utf-8"""					) as f:
								__UpperCAmelCase :   List[str]    					=  f.readlines()
					return cls(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							suppress_parsing_errors=__UpperCAmelCase					)





		@classmethod
		def 				__A							(  cls			,							__UpperCAmelCase			,							__UpperCAmelCase = None			,							__UpperCAmelCase = "root"			,							__UpperCAmelCase = False					)							->  str:

					'''simple docstring'''
					__UpperCAmelCase :   Any    					=  string.split("""\n"""					)
					return cls(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase			,							suppress_parsing_errors=__UpperCAmelCase					)





		def 				__A							(  self			,							__UpperCAmelCase = False					)							->  List[str]:

					'''simple docstring'''
					# Skip Tags
					__UpperCAmelCase :   str    					=  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:
								__UpperCAmelCase :   int    					=  self.lines[line_count + 1 :]  # Get the last + 1 th item.
					else:
								__UpperCAmelCase :   int    					=  self.lines[self.tag_count :]
					super().parse(suppress_parsing_errors=__UpperCAmelCase					)





		def __str__(  self					)							->  Any:

					'''simple docstring'''
					return str(self.to_dict()					)





		def 				__A							(  self			,							__UpperCAmelCase					)							->  str:

					'''simple docstring'''
					__UpperCAmelCase :   Optional[Any]    					=  []
					__UpperCAmelCase :   Optional[int]    					=  []
					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.
					__UpperCAmelCase :   Union[str, Any]    					=  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
								__UpperCAmelCase :   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
											__UpperCAmelCase					,	__UpperCAmelCase					,	__UpperCAmelCase :   Tuple    					=  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)









'''simple docstring'''
from typing import TYPE_CHECKING

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


_UpperCamelCase									=      {'''configuration_t5''': ['''T5_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''T5Config''', '''T5OnnxConfig''']}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCamelCase									=      ['''T5Tokenizer''']

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCamelCase									=      ['''T5TokenizerFast''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCamelCase									=      [
					    '''T5_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''T5EncoderModel''',
					    '''T5ForConditionalGeneration''',
					    '''T5Model''',
					    '''T5PreTrainedModel''',
					    '''load_tf_weights_in_t5''',
					    '''T5ForQuestionAnswering''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCamelCase									=      [
					    '''TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFT5EncoderModel''',
					    '''TFT5ForConditionalGeneration''',
					    '''TFT5Model''',
					    '''TFT5PreTrainedModel''',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCamelCase									=      [
					    '''FlaxT5EncoderModel''',
					    '''FlaxT5ForConditionalGeneration''',
					    '''FlaxT5Model''',
					    '''FlaxT5PreTrainedModel''',
					]


if TYPE_CHECKING:
					from .configuration_ta import T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TaConfig, TaOnnxConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_ta import TaTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_ta_fast import TaTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_ta import (
										    T5_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TaEncoderModel,
										    TaForConditionalGeneration,
										    TaForQuestionAnswering,
										    TaModel,
										    TaPreTrainedModel,
										    load_tf_weights_in_ta,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_ta import (
										    TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFTaEncoderModel,
										    TFTaForConditionalGeneration,
										    TFTaModel,
										    TFTaPreTrainedModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_ta import (
										    FlaxTaEncoderModel,
										    FlaxTaForConditionalGeneration,
										    FlaxTaModel,
										    FlaxTaPreTrainedModel,
										)


else:
					import sys

					_UpperCamelCase									=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




