
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


lowercase__				:				Any						=      "https://github.com/huggingface/datasets/tree/main/src/datasets/utils"
lowercase__				:				str						=      F"{BASE_REF_URL}/{__file__}"
lowercase__				:				str						=      logging.getLogger(__name__)




def 						A_			(				snake_case				: str			)   ->     Tuple[Any, str]:



						'''simple docstring'''

						__UpperCamelCase  	=      pkg_resources.read_text(snake_case			,   snake_case			)
						return yaml.safe_load(snake_case			), f"{BASE_REF_URL}/resources/{resource}"


lowercase__		,	lowercase__				:				Any						=      load_yaml_resource("readme_structure.yaml")

lowercase__				:				List[Any]						=      [
    "[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
lowercase__				:				Any						=      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      )-> int:





													'''simple docstring'''






													__UpperCamelCase  	=      name
													__UpperCamelCase  	=      level
													__UpperCamelCase  	=      lines
													__UpperCamelCase  	=      ''''''
													__UpperCamelCase  	=      True
													__UpperCamelCase  	=      {}
													__UpperCamelCase  	=      []
													__UpperCamelCase  	=      []
													if self.lines is not None:
																			self.parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE_      )



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_ = False      )-> Optional[Any]:





													'''simple docstring'''






													__UpperCamelCase  	=      ''''''
													__UpperCamelCase  	=      []
													__UpperCamelCase  	=      False
													for line in self.lines:
																			if line.strip(''' \n'''      ) == "":
																									continue
																			elif line.strip(''' \n'''      )[:3] == "```":
																									__UpperCamelCase  	=      not code_start
																			elif line.split()[0] == self.level + "#" and not code_start:
																									if current_sub_level != "":
																															__UpperCamelCase  	=      Section(SCREAMING_SNAKE_CASE_  ,						self.level + '''#'''  ,						SCREAMING_SNAKE_CASE_      )
																															__UpperCamelCase  	=      []
																									else:
																															if current_lines != []:
																																					self.text += "".join(SCREAMING_SNAKE_CASE_      ).strip()
																																					if self.text != "" and self.text not in FILLER_TEXT:
																																											__UpperCamelCase  	=      False
																																					__UpperCamelCase  	=      []

																									__UpperCamelCase  	=      ''' '''.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."      )
																									__UpperCamelCase  	=      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:
																																					__UpperCamelCase  	=      False

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



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_      )-> ReadmeValidatorOutput:





													'''simple docstring'''






													__UpperCamelCase  	=      []
													__UpperCamelCase  	=      []
													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  	=      [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  	=      [subsection['''name'''] for subsection in structure['''subsections''']]
																									__UpperCamelCase  	=      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}`."      )
																																					__UpperCamelCase  	=      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  	=      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 							SCREAMING_SNAKE_CASE__     (				SCREAMING_SNAKE_CASE_     ):  # Level 0

							"""simple docstring"""






							def __init__(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_ = None  ,						SCREAMING_SNAKE_CASE_ = False      )-> List[str]:





													'''simple docstring'''






													super().__init__(name=SCREAMING_SNAKE_CASE_  ,						level=''''''      )  # Not using lines here as we need to use a child class parse
													__UpperCamelCase  	=      structure
													__UpperCamelCase  	=      -2
													__UpperCamelCase  	=      0
													__UpperCamelCase  	=      lines
													if self.lines is not None:
																			self.parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE_      )



							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






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



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





													'''simple docstring'''






													with open(SCREAMING_SNAKE_CASE_  ,						encoding='''utf-8'''      ) as f:
																			__UpperCamelCase  	=      f.readlines()
													return cls(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						suppress_parsing_errors=SCREAMING_SNAKE_CASE_      )



							@classmethod
							def      A__		(	cls  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_ = None  ,						SCREAMING_SNAKE_CASE_ = "root"  ,						SCREAMING_SNAKE_CASE_ = False      )-> Tuple:





													'''simple docstring'''






													__UpperCamelCase  	=      string.split('''\n'''      )
													return cls(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						suppress_parsing_errors=SCREAMING_SNAKE_CASE_      )



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_ = False      )-> Dict:





													'''simple docstring'''






													__UpperCamelCase  	=      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  	=      self.lines[line_count + 1 :]  # Get the last + 1 th item.
													else:
																			__UpperCamelCase  	=      self.lines[self.tag_count :]
													super().parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE_      )



							def __str__(	self      )-> Optional[Any]:





													'''simple docstring'''






													return str(self.to_dict()      )



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_      )-> Any:





													'''simple docstring'''






													__UpperCamelCase  	=      []
													__UpperCamelCase  	=      []
													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  	=      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(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  	=      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

				lowercase__				:				Dict						=      ArgumentParser(usage="Validate the content (excluding YAML tags) of a README.md file.")
				ap.add_argument("readme_filepath")
				lowercase__				:				Optional[Any]						=      ap.parse_args()
				lowercase__				:				Any						=      Path(args.readme_filepath)
				lowercase__				:				str						=      ReadMe.from_readme(readme_filepath)






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,
)


lowercase__				:				Dict						=      {
    "configuration_switch_transformers": [
        "SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "SwitchTransformersConfig",
        "SwitchTransformersOnnxConfig",
    ]
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase__				:				List[Any]						=      [
				    "SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "SwitchTransformersEncoderModel",
				    "SwitchTransformersForConditionalGeneration",
				    "SwitchTransformersModel",
				    "SwitchTransformersPreTrainedModel",
				    "SwitchTransformersTop1Router",
				    "SwitchTransformersSparseMLP",
				]


if TYPE_CHECKING:
				from .configuration_switch_transformers import (
				    SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    SwitchTransformersConfig,
				    SwitchTransformersOnnxConfig,
				)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_switch_transformers import (
								    SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SwitchTransformersEncoderModel,
								    SwitchTransformersForConditionalGeneration,
								    SwitchTransformersModel,
								    SwitchTransformersPreTrainedModel,
								    SwitchTransformersSparseMLP,
								    SwitchTransformersTopaRouter,
								)


else:
				import sys

				lowercase__				:				List[Any]						=      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




