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


_lowercase				:						List[str]												= "https://github.com/huggingface/datasets/tree/main/src/datasets/utils"
_lowercase				:						Optional[Any]												= f"""{BASE_REF_URL}/{__file__}"""
_lowercase				:						int												= logging.getLogger(__name__)
def       snake_case_	(       __SCREAMING_SNAKE_CASE      :				str							):



						"""simple docstring"""





						lowercase_			:  Optional[int]									= pkg_resources.read_text(__SCREAMING_SNAKE_CASE   ,   __SCREAMING_SNAKE_CASE							)
						return yaml.safe_load(__SCREAMING_SNAKE_CASE							), F'''{BASE_REF_URL}/resources/{resource}'''


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

_lowercase				:						Optional[int]												= [
    "[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				:						List[Any]												= Tuple[dict, List[str], List[str]]






class 				lowerCAmelCase__     :






					def __init__(     self       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE = None       ,							__SCREAMING_SNAKE_CASE = False	):


											"""simple docstring"""





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






					def 			_snake_case					(     self       ,							__SCREAMING_SNAKE_CASE = False	):


											"""simple docstring"""





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

																							lowercase_			:  int									= ''' '''.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.'''	)
																							lowercase_			:  Tuple									= 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:
																																			lowercase_			:  Any									= 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(__SCREAMING_SNAKE_CASE	)






					def 			_snake_case					(     self       ,							__SCREAMING_SNAKE_CASE	):


											"""simple docstring"""





											lowercase_			:  List[Any]									= []
											lowercase_			:  Optional[int]									= []
											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_			:  Tuple									= [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_			:  List[Any]									= [subsection['''name'''] for subsection in structure['''subsections''']]
																							lowercase_			:  List[Any]									= 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}`.'''	)
																																			lowercase_			:  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:
																																									lowercase_		,				lowercase_		,				lowercase_			:  Dict									= 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	):


											"""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 				lowerCAmelCase__     (						lowerCamelCase_  ):  # Level 0






					def __init__(     self       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE = None       ,							__SCREAMING_SNAKE_CASE = False	):


											"""simple docstring"""





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






					def 			_snake_case					(     self	):


											"""simple docstring"""





											if self.structure is None:
																	lowercase_		,				lowercase_		,				lowercase_			:  Optional[int]									= self._validate(__SCREAMING_SNAKE_CASE	)
											else:
																	lowercase_		,				lowercase_		,				lowercase_			:  List[Any]									= self._validate(self.structure	)
											if error_list != [] or warning_list != []:
																	lowercase_			:  Optional[int]									= '''\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(__SCREAMING_SNAKE_CASE	)






					@classmethod
					def 			_snake_case					(     cls       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE = None       ,							__SCREAMING_SNAKE_CASE = False	):


											"""simple docstring"""





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






					@classmethod
					def 			_snake_case					(     cls       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE = None       ,							__SCREAMING_SNAKE_CASE = "root"       ,							__SCREAMING_SNAKE_CASE = False	):


											"""simple docstring"""





											lowercase_			:  Tuple									= string.split('''\n'''	)
											return cls(__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE       ,							__SCREAMING_SNAKE_CASE       ,							suppress_parsing_errors=__SCREAMING_SNAKE_CASE	)






					def 			_snake_case					(     self       ,							__SCREAMING_SNAKE_CASE = False	):


											"""simple docstring"""





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






					def __str__(     self	):


											"""simple docstring"""





											return str(self.to_dict()	)






					def 			_snake_case					(     self       ,							__SCREAMING_SNAKE_CASE	):


											"""simple docstring"""





											lowercase_			:  Dict									= []
											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_			:  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
																	lowercase_			:  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
																							lowercase_		,				lowercase_		,				lowercase_			:  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

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





'''simple docstring'''







def       snake_case_	(       __SCREAMING_SNAKE_CASE      :				int = 998001							):



						"""simple docstring"""





						lowercase_			:  Dict									= 0
						for i in range(999   ,   99   ,   -1							):  # 3 digit numbers range from 999 down to 100
												for j in range(999   ,   99   ,   -1							):
																		lowercase_			:  int									= str(i * j							)
																		if product_string == product_string[::-1] and i * j < n:
																								lowercase_			:  str									= max(__SCREAMING_SNAKE_CASE   ,   i * j							)
						return answer


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



