




"""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_      =					'https://github.com/huggingface/datasets/tree/main/src/datasets/utils'
SCREAMING_SNAKE_CASE_      =					f'{BASE_REF_URL}/{__file__}'
SCREAMING_SNAKE_CASE_      =					logging.getLogger(__name__)





def     __snake_case   (							_lowercase						):


				"""simple docstring"""







				UpperCamelCase										=  pkg_resources.read_text(_UpperCAmelCase ,_UpperCAmelCase						)
				return yaml.safe_load(_UpperCAmelCase						), f'{BASE_REF_URL}/resources/{resource}'


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

SCREAMING_SNAKE_CASE_      =					[
    '[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_      =					Tuple[dict, List[str], List[str]]

class 							snake_case_ :







			"""simple docstring"""




			def __init__(		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_ = None					,				lowerCamelCase_ = False)							->      List[Any]:
							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      UpperCAmelCase__ (		self					,				lowerCamelCase_ = False)							->      Optional[Any]:
							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      UpperCAmelCase__ (		self					,				lowerCamelCase_)							->      List[str]:
							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      UpperCAmelCase__ (		self)							->      Optional[Any]:
							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_ (				lowerCamelCase__ ):  # Level 0







			"""simple docstring"""




			def __init__(		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_ = None					,				lowerCamelCase_ = False)							->      Union[str, Any]:
							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      UpperCAmelCase__ (		self)							->      Union[str, Any]:
							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      UpperCAmelCase__ (		cls					,				lowerCamelCase_					,				lowerCamelCase_ = None					,				lowerCamelCase_ = False)							->      str:
							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      UpperCAmelCase__ (		cls					,				lowerCamelCase_					,				lowerCamelCase_ = None					,				lowerCamelCase_ = "root"					,				lowerCamelCase_ = False)							->      List[str]:
							UpperCamelCase										=  string.split('''\n''')
							return cls(SCREAMING_SNAKE_CASE_					,				SCREAMING_SNAKE_CASE_					,				SCREAMING_SNAKE_CASE_					,				suppress_parsing_errors=SCREAMING_SNAKE_CASE_)







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_ = False)							->      Tuple:
							# Skip Tags
							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)							->      Union[str, Any]:
							return str(self.to_dict())







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_)							->      Dict:
							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

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





"""simple docstring"""







class 							snake_case_ :







   """simple docstring"""




   def __init__(		self					,				lowerCamelCase_=None)							->      Tuple:
       UpperCamelCase										=  data
       UpperCamelCase										=  None







   def __repr__(		self)							->      Union[str, Any]:
       UpperCamelCase										=  ''''''
       UpperCamelCase										=  self
       while temp:
           string_rep += F'<{temp.data}> ---> '
           UpperCamelCase										=  temp.next
       string_rep += "<END>"
       return string_rep





def     __snake_case   (							_lowercase						):


    """simple docstring"""







    if not elements_list:
        raise Exception('''The Elements List is empty'''						)

    # Set first element as Head
    UpperCamelCase										=  Node(elements_list[0]						)
    UpperCamelCase										=  head
    # Loop through elements from position 1
    for data in elements_list[1:]:
        UpperCamelCase										=  Node(_lowercase						)
        UpperCamelCase										=  current.next
    return head


SCREAMING_SNAKE_CASE_      =					[1, 3, 5, 32, 44, 12, 43]
print(f'List: {list_data}')
print('Creating Linked List from List.')
SCREAMING_SNAKE_CASE_      =					make_linked_list(list_data)
print('Linked List:')


print(linked_list)