






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     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Optional[Any]    =			pkg_resources.read_text(UpperCamelCase__  ,     UpperCamelCase__       )
  return yaml.safe_load(UpperCamelCase__       ), 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    :


 def __init__(  self	:		Optional[int]							,		UpperCAmelCase__	:		str							,		UpperCAmelCase__	:		str							,		UpperCAmelCase__	:		List[str] = None							,		UpperCAmelCase__	:		bool = False							)      -> Any:
   _a						: List[Any]    =			name
   _a						: Dict    =			level
   _a						: Tuple    =			lines
   _a						: Optional[int]    =			""""""
   _a						: str    =			True
   _a						: List[str]    =			{}
   _a						: str    =			[]
   _a						: Optional[Any]    =			[]
   if self.lines is not None:
     self.parse(suppress_parsing_errors=UpperCAmelCase__							)


 def _lowercase			(  self	:		Optional[int]							,		UpperCAmelCase__	:		bool = False							)      -> str:
   _a						: int    =			""""""
   _a						: Dict    =			[]
   _a						: Any    =			False
   for line in self.lines:
     if line.strip(""" \n"""							) == "":
       continue
     elif line.strip(""" \n"""							)[:3] == "```":
       _a						: List[str]    =			not code_start
     elif line.split()[0] == self.level + "#" and not code_start:
       if current_sub_level != "":
         _a						: Dict    =			Section(UpperCAmelCase__							,		self.level + """#"""							,		UpperCAmelCase__							)
         _a						: Any    =			[]
       else:
         if current_lines != []:
           self.text += "".join(UpperCAmelCase__							).strip()
           if self.text != "" and self.text not in FILLER_TEXT:
             _a						: Dict    =			False
           _a						: Tuple    =			[]

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

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


 def _lowercase			(  self	:		List[str]							,		UpperCAmelCase__	:		dict							)      -> ReadmeValidatorOutput:
   _a						: Any    =			[]
   _a						: 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
       _a						: Union[str, 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
       _a						: Dict    =			[subsection["""name"""] for subsection in structure["""subsections"""]]
       _a						: List[Any]    =			False
       for idx, name in enumerate(UpperCAmelCase__							):
         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						: Optional[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						: Optional[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 _lowercase			(  self	:		int							)      -> dict:
   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    (			snake_case_   ):  # Level 0


 def __init__(  self	:		int							,		UpperCAmelCase__	:		str							,		UpperCAmelCase__	:		List[str]							,		UpperCAmelCase__	:		dict = None							,		UpperCAmelCase__	:		bool = False							)      -> Tuple:
   super().__init__(name=UpperCAmelCase__							,		level=""""""							)  # Not using lines here as we need to use a child class parse
   _a						: int    =			structure
   _a						: Dict    =			-2
   _a						: Dict    =			0
   _a						: Union[str, Any]    =			lines
   if self.lines is not None:
     self.parse(suppress_parsing_errors=UpperCAmelCase__							)


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


 @classmethod
 def _lowercase			(  cls	:		List[Any]							,		UpperCAmelCase__	:		Path							,		UpperCAmelCase__	:		dict = None							,		UpperCAmelCase__	:		bool = False							)      -> Optional[int]:
   with open(UpperCAmelCase__							,		encoding="""utf-8"""							) as f:
     _a						: str    =			f.readlines()
   return cls(UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		suppress_parsing_errors=UpperCAmelCase__							)


 @classmethod
 def _lowercase			(  cls	:		Tuple							,		UpperCAmelCase__	:		str							,		UpperCAmelCase__	:		dict = None							,		UpperCAmelCase__	:		str = "root"							,		UpperCAmelCase__	:		bool = False							)      -> Union[str, Any]:
   _a						: Any    =			string.split("""\n"""							)
   return cls(UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		suppress_parsing_errors=UpperCAmelCase__							)


 def _lowercase			(  self	:		Optional[int]							,		UpperCAmelCase__	:		bool = False							)      -> List[str]:
   # Skip Tags
   _a						: 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:
     _a						: str    =			self.lines[line_count + 1 :]  # Get the last + 1 th item.
   else:
     _a						: Optional[Any]    =			self.lines[self.tag_count :]
   super().parse(suppress_parsing_errors=UpperCAmelCase__							)


 def __str__(  self	:		Tuple							)      -> List[str]:
   return str(self.to_dict()							)







 def _lowercase			(  self	:		Dict							,		UpperCAmelCase__	:		Optional[Any]							)      -> int:
   _a						: Union[str, Any]    =			[]
   _a						: List[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.
   _a						: 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
     _a						: str    =			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						: Tuple    =			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 __future__ import annotations

import math
from itertools import permutations

def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''

  if 1 < number < 4:
    # 2 and 3 are primes
    return True
  elif number < 2 or number % 2 == 0 or number % 3 == 0:
    # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
    return False

  # All primes number are in format of 6k +/- 1
  for i in range(5  ,     int(math.sqrt(UpperCamelCase__       ) + 1       )  ,     6       ):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True

def     lowerCAmelCase__  (  UpperCamelCase__ = 7       ):



  '''simple docstring'''
  _a						: Tuple    =			"""""".join(str(UpperCamelCase__       ) for i in range(1  ,     n + 1       )       )
  _a						: str    =			[int("""""".join(UpperCamelCase__       )       ) for i in permutations(UpperCamelCase__  ,     UpperCamelCase__       )]
  _a						: Union[str, Any]    =			[num for num in perm_list if is_prime(UpperCamelCase__       )]
  return max(UpperCamelCase__       ) if pandigitals else 0


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

