





"""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  a_       (							_lowercase     ):
						_UpperCamelCase    :      int						     =					pkg_resources.read_text(_lowercase ,		_lowercase     )
						return yaml.safe_load(_lowercase     ), 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	:					List[str],				lowerCAmelCase__	:					str,				lowerCAmelCase__	:					str,				lowerCAmelCase__	:					List[str] = None,				lowerCAmelCase__	:					bool = False							)			->   Dict:




										'''simple docstring'''



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






				def        snake_case			(				self	:					Optional[Any],				lowerCAmelCase__	:					bool = False							)			->   Optional[Any]:




										'''simple docstring'''



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

																						_UpperCamelCase    :      List[str]						     =					''' '''.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."""							)
																						_UpperCamelCase    :      List[Any]						     =					Section(lowerCAmelCase__,				self.level + '''#''',				lowerCAmelCase__							)
																else:
																						if current_lines != []:
																												self.text += "".join(lowerCAmelCase__							).strip()
																												if self.text != "" and self.text not in FILLER_TEXT:
																																		_UpperCamelCase    :      Optional[int]						     =					False

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






				def        snake_case			(				self	:					str,				lowerCAmelCase__	:					dict							)			->   ReadmeValidatorOutput:




										'''simple docstring'''



										_UpperCamelCase    :      List[str]						     =					[]
										_UpperCamelCase    :      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
																						_UpperCamelCase    :      List[str]						     =					[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    :      Optional[int]						     =					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}`."""							)
																																		_UpperCamelCase    :      Union[str, 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:
																																								_UpperCamelCase     ,							_UpperCamelCase     ,							_UpperCamelCase    :      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        snake_case			(				self	:					int							)			->   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		(   _lowerCAmelCase       ):  # Level 0






				def __init__(				self	:					List[Any],				lowerCAmelCase__	:					str,				lowerCAmelCase__	:					List[str],				lowerCAmelCase__	:					dict = None,				lowerCAmelCase__	:					bool = False							)			->   Tuple:




										'''simple docstring'''



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






				def        snake_case			(				self	:					str							)			->   Any:




										'''simple docstring'''



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






				@classmethod
				def        snake_case			(				cls	:					int,				lowerCAmelCase__	:					Path,				lowerCAmelCase__	:					dict = None,				lowerCAmelCase__	:					bool = False							)			->   List[str]:




										'''simple docstring'''



										with open(lowerCAmelCase__,				encoding='''utf-8'''							) as f:
																_UpperCamelCase    :      Union[str, Any]						     =					f.readlines()
										return cls(lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				suppress_parsing_errors=lowerCAmelCase__							)






				@classmethod
				def        snake_case			(				cls	:					Dict,				lowerCAmelCase__	:					str,				lowerCAmelCase__	:					dict = None,				lowerCAmelCase__	:					str = "root",				lowerCAmelCase__	:					bool = False							)			->   Any:




										'''simple docstring'''



										_UpperCamelCase    :      Optional[int]						     =					string.split('''\n'''							)
										return cls(lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				suppress_parsing_errors=lowerCAmelCase__							)






				def        snake_case			(				self	:					Any,				lowerCAmelCase__	:					bool = False							)			->   Tuple:




										'''simple docstring'''



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






				def __str__(				self	:					Any							)			->   int:




										'''simple docstring'''



										return str(self.to_dict()							)






				def        snake_case			(				self	:					List[str],				lowerCAmelCase__	:					str							)			->   int:




										'''simple docstring'''



										_UpperCamelCase    :      List[str]						     =					[]
										_UpperCamelCase    :      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.
										_UpperCamelCase    :      List[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    :      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
																						_UpperCamelCase     ,							_UpperCamelCase     ,							_UpperCamelCase    :      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)










"""simple docstring"""




def  a_       (							_lowercase ,		_lowercase     ):
						sequence.append(_lowercase     )

						_UpperCamelCase    :      int						     =					0
						while sequence[index] != target:
												index += 1

						sequence.pop()

						if index == len(_lowercase     ):
												return None

						return index


if __name__ == "__main__":
						UpperCamelCase_     =input("""Enter numbers separated by comma:\n""").strip()
						UpperCamelCase_     =[int(item) for item in user_input.split(""",""")]

						UpperCamelCase_     =input("""Enter a single number to be found in the list:\n""")
						UpperCamelCase_     =int(target_input)
						UpperCamelCase_     =sentinel_linear_search(sequence, target)
						if result is not None:
												print(F"{target} found at positions: {result}")
						else:
												print("""Not found""")



