




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


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




def     snake_case__     (			lowerCamelCase__					: str      ) -> Tuple[Any, str]:
					A_			:  Any			=				pkg_resources.read_text(lowerCamelCase__      ,		lowerCamelCase__      )
					return yaml.safe_load(lowerCamelCase__      ), f'{BASE_REF_URL}/resources/{resource}'


snake_case__							,    snake_case__ 							=    load_yaml_resource("""readme_structure.yaml""")

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






class      UpperCamelCase_  :







						"""simple docstring"""


						def __init__(  self   :							List[Any]				,			_lowerCamelCase   :							str				,			_lowerCamelCase   :							str				,			_lowerCamelCase   :							List[str] = None				,			_lowerCamelCase   :							bool = False     ):





											"""simple docstring"""







											A_			:  Optional[Any]			=				name
											A_			:  Any			=				level
											A_			:  Union[str, Any]			=				lines
											A_			:  Optional[int]			=				''''''
											A_			:  Optional[Any]			=				True
											A_			:  int			=				{}
											A_			:  str			=				[]
											A_			:  str			=				[]
											if self.lines is not None:
																self.parse(suppress_parsing_errors=_lowerCamelCase     )







						def    _a     (  self   :							Optional[int]				,			_lowerCamelCase   :							bool = False     ):





											"""simple docstring"""







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

																					A_			:  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.'     )
																					A_			:  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:
																															A_			:  str			=				False

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







						def    _a     (  self   :							List[Any]				,			_lowerCamelCase   :							dict     ):





											"""simple docstring"""







											A_			:  Union[str, Any]			=				[]
											A_			:  List[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
																					A_			:  int			=				[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
																					A_			:  Tuple			=				[subsection['''name'''] for subsection in structure['''subsections''']]
																					A_			:  Dict			=				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}`.'     )
																															A_			:  int			=				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:
																																				A_			,A_			,A_			:  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    _a     (  self   :							List[Any]     ):





											"""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      UpperCamelCase_  (a__  ):  # Level 0







						"""simple docstring"""


						def __init__(  self   :							str				,			_lowerCamelCase   :							str				,			_lowerCamelCase   :							List[str]				,			_lowerCamelCase   :							dict = None				,			_lowerCamelCase   :							bool = False     ):





											"""simple docstring"""







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







						def    _a     (  self   :							Dict     ):





											"""simple docstring"""







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







						@classmethod
						def    _a     (  cls   :							Union[str, Any]				,			_lowerCamelCase   :							Path				,			_lowerCamelCase   :							dict = None				,			_lowerCamelCase   :							bool = False     ):





											"""simple docstring"""







											with open(_lowerCamelCase				,			encoding='''utf-8'''     ) as f:
																A_			:  List[str]			=				f.readlines()
											return cls(_lowerCamelCase				,			_lowerCamelCase				,			_lowerCamelCase				,			suppress_parsing_errors=_lowerCamelCase     )







						@classmethod
						def    _a     (  cls   :							Optional[Any]				,			_lowerCamelCase   :							str				,			_lowerCamelCase   :							dict = None				,			_lowerCamelCase   :							str = "root"				,			_lowerCamelCase   :							bool = False     ):





											"""simple docstring"""







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







						def    _a     (  self   :							str				,			_lowerCamelCase   :							bool = False     ):





											"""simple docstring"""







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







						def __str__(  self   :							Union[str, Any]     ):





											"""simple docstring"""







											return str(self.to_dict()     )







						def    _a     (  self   :							List[str]				,			_lowerCamelCase   :							str     ):





											"""simple docstring"""







											A_			:  Tuple			=				[]
											A_			:  Tuple			=				[]
											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.
											A_			:  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
																A_			:  Union[str, 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
																					A_			,A_			,A_			:  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

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









'''simple docstring'''




from itertools import permutations




def     snake_case__     (			lowerCamelCase__					: int = 5      ) -> int:
					if gon_side < 3 or gon_side > 5:
										raise ValueError('''gon_side must be in the range [3, 5]'''      )

					# Since it's 16, we know 10 is on the outer ring
					# Put the big numbers at the end so that they are never the first number
					A_			:  int			=				list(range(gon_side + 1      ,		0      ,		-1      )      )
					A_			:  List[Any]			=				list(range(gon_side + 2      ,		gon_side * 2 + 1      )      )

					for perm in permutations(small_numbers + big_numbers      ):
										A_			:  Optional[int]			=				generate_gon_ring(lowerCamelCase__      ,		list(lowerCamelCase__      )      )
										if is_magic_gon(lowerCamelCase__      ):
															return int(''''''.join(str(lowerCamelCase__      ) for n in numbers      )      )

					A_			:  Optional[Any]			=				f'Magic {gon_side}-gon ring is impossible'
					raise ValueError(lowerCamelCase__      )




def     snake_case__     (			lowerCamelCase__					: int      ,		lowerCamelCase__					: list[int]      ) -> list[int]:
					A_			:  List[Any]			=				[0] * (gon_side * 3)
					A_			:  Optional[Any]			=				perm[0:3]
					perm.append(perm[1]      )

					A_			:  Optional[Any]			=				1 if gon_side < 5 else 2

					for i in range(1      ,		len(lowerCamelCase__      ) // 3 + magic_number      ):
										A_			:  List[str]			=				perm[2 * i + 1]
										A_			:  str			=				result[3 * i - 1]
										A_			:  Union[str, Any]			=				perm[2 * i + 2]

					return result




def     snake_case__     (			lowerCamelCase__					: list[int]      ) -> bool:
					if len(lowerCamelCase__      ) % 3 != 0:
										raise ValueError('''a gon ring should have a length that is a multiple of 3'''      )

					if min(numbers[::3]      ) != numbers[0]:
										return False

					A_			:  Union[str, Any]			=				sum(numbers[:3]      )

					return all(sum(numbers[i : i + 3]      ) == total for i in range(3      ,		len(lowerCamelCase__      )      ,		3      )      )


if __name__ == "__main__":
							print(solution())



