






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


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





def 						lowercase__(A						)				->Tuple[Any, str]:




						"""simple docstring"""



						lowercase__				:      Union[str, Any]=       pkg_resources.read_text(A					,		A						)
						return yaml.safe_load(A						), f'''{BASE_REF_URL}/resources/{resource}'''


a					,		a :				Dict      					=		load_yaml_resource("""readme_structure.yaml""")

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


class     __UpperCAmelCase:




						"""simple docstring"""




						def __init__(   self       ,  snake_case__       ,  snake_case__       ,  snake_case__ = None       ,  snake_case__ = False			):
												'''simple docstring'''
												lowercase__				:      List[str]=       name
												lowercase__				:      Any=       level
												lowercase__				:      List[str]=       lines
												lowercase__				:      int=       ""
												lowercase__				:      str=       True
												lowercase__				:      Union[str, Any]=       {}
												lowercase__				:      int=       []
												lowercase__				:      Any=       []
												if self.lines is not None:
																		self.parse(suppress_parsing_errors=snake_case__			)




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

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

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




						def 		UpperCAmelCase_       (   self       ,  snake_case__			):
												'''simple docstring'''
												lowercase__				:      List[Any]=       []
												lowercase__				:      List[str]=       []
												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
																								lowercase__				:      List[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
																								lowercase__				:      Union[str, Any]=       [subsection["name"] for subsection in structure["subsections"]]
																								lowercase__				:      Tuple=       False
																								for idx, name in enumerate(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}`.'''			)
																																				lowercase__				:      Optional[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:
																																										lowercase__,	lowercase__,	lowercase__				:      Union[str, 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 		UpperCAmelCase_       (   self			):
												'''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(   SCREAMING_SNAKE_CASE__							):  # Level 0




						"""simple docstring"""




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




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




						@classmethod
						def 		UpperCAmelCase_       (   cls       ,  snake_case__       ,  snake_case__ = None       ,  snake_case__ = False			):
												'''simple docstring'''
												with open(snake_case__       ,  encoding="utf-8"			) as f:
																		lowercase__				:      List[str]=       f.readlines()
												return cls(snake_case__       ,  snake_case__       ,  snake_case__       ,  suppress_parsing_errors=snake_case__			)




						@classmethod
						def 		UpperCAmelCase_       (   cls       ,  snake_case__       ,  snake_case__ = None       ,  snake_case__ = "root"       ,  snake_case__ = False			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       string.split("\n"			)
												return cls(snake_case__       ,  snake_case__       ,  snake_case__       ,  suppress_parsing_errors=snake_case__			)




						def 		UpperCAmelCase_       (   self       ,  snake_case__ = False			):
												'''simple docstring'''
												# Skip Tags
												lowercase__				:      Optional[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:
																		lowercase__				:      Optional[int]=       self.lines[line_count + 1 :]  # Get the last + 1 th item.
												else:
																		lowercase__				:      List[Any]=       self.lines[self.tag_count :]
												super().parse(suppress_parsing_errors=snake_case__			)




						def __str__(   self			):
												'''simple docstring'''
												return str(self.to_dict()			)




						def 		UpperCAmelCase_       (   self       ,  snake_case__			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       []
												lowercase__				:      Any=       []
												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.
												lowercase__				:      int=       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
																		lowercase__				:      Tuple=       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
																								lowercase__,	lowercase__,	lowercase__				:      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

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














"""simple docstring"""







import math
from decimal import Decimal, getcontext





def 						lowercase__(A = 4_000_000						)				->int:




						"""simple docstring"""



						try:
												lowercase__				:      int=       int(A						)
						except (TypeError, ValueError):
												raise TypeError("Parameter n must be int or castable to int."						)
						if n <= 0:
												raise ValueError("Parameter n must be greater than or equal to one."						)
						lowercase__				:      Dict=       100
						lowercase__				:      Optional[Any]=       (Decimal(5						) ** Decimal(0.5						) + 1) / Decimal(2						)

						lowercase__				:      str=       (math.floor(math.log(n * (phi + 2)					,		A						) - 1						) // 3) * 3 + 2
						lowercase__				:      Optional[Any]=       Decimal(round(phi ** Decimal(index + 1						)						)						) / (phi + 2)
						lowercase__				:      Tuple=       num // 2
						return int(A						)


if __name__ == "__main__":
			print(F"""{solution() = }""")






