






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


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




def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase							):


   """simple docstring"""




   lowercase_		:      List[Any]          =       pkg_resources.read_text(_UpperCamelCase  ,						_UpperCamelCase							)
   return yaml.safe_load(_UpperCamelCase							), F"""{BASE_REF_URL}/resources/{resource}"""


UpperCamelCase__	=     load_yaml_resource('readme_structure.yaml')

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


class     _UpperCAmelCase  :




    def __init__(     self					:    Optional[Any]					,       a					:    Tuple					,       a					:    Any					,       a					:    Any = None					,       a					:    Optional[Any] = False     ):






       '''simple docstring'''






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




    def 			lowerCAmelCase__			(     self					:    Optional[int]					,       a					:    Any = False     ):






       '''simple docstring'''






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

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

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




    def 			lowerCAmelCase__			(     self					:    Optional[int]					,       a					:    Any     ):






       '''simple docstring'''






       lowercase_		:      Any          =       []
       lowercase_		:      Tuple          =       []
       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_		:      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
             lowercase_		:      Optional[Any]          =       [subsection['name'] for subsection in structure['subsections']]
             lowercase_		:      str          =       False
             for idx, name in enumerate(_A     ):
                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_		:      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 			lowerCAmelCase__			(     self					:    Optional[int]     ):






       '''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  (						snake_case__     ):  # Level 0




    def __init__(     self					:    Any					,       a					:    Optional[int]					,       a					:    List[Any]					,       a					:    str = None					,       a					:    Dict = False     ):






       '''simple docstring'''






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




    def 			lowerCAmelCase__			(     self					:    Any     ):






       '''simple docstring'''






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




    @classmethod
    def 			lowerCAmelCase__			(     cls					:    int					,       a					:    Optional[int]					,       a					:    Optional[Any] = None					,       a					:    Any = False     ):






       '''simple docstring'''






       with open(_A					,       encoding="utf-8"     ) as f:
          lowercase_		:      str          =       f.readlines()
       return cls(_A					,       _A					,       _A					,       suppress_parsing_errors=_A     )




    @classmethod
    def 			lowerCAmelCase__			(     cls					:    Optional[int]					,       a					:    int					,       a					:    Tuple = None					,       a					:    Optional[Any] = "root"					,       a					:    int = False     ):






       '''simple docstring'''






       lowercase_		:      Any          =       string.split("\n"     )
       return cls(_A					,       _A					,       _A					,       suppress_parsing_errors=_A     )




    def 			lowerCAmelCase__			(     self					:    Tuple					,       a					:    List[str] = False     ):






       '''simple docstring'''






       lowercase_		:      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_		:      List[str]          =       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=_A     )




    def __str__(     self					:    str     ):






       '''simple docstring'''






       return str(self.to_dict()     )





    def 			lowerCAmelCase__			(     self					:    Union[str, Any]					,       a					:    List[Any]     ):






       '''simple docstring'''






       lowercase_		:      List[str]          =       []
       lowercase_		:      List[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_		:      Optional[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_		:      List[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_		:      List[str]          =       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

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












'''simple docstring'''
def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase  ,						_UpperCamelCase							):


   """simple docstring"""




   sequence.append(_UpperCamelCase							)

   lowercase_		:      Union[str, Any]          =       0
   while sequence[index] != target:
      index += 1

   sequence.pop()

   if index == len(_UpperCamelCase							):
      return None

   return index


if __name__ == "__main__":
 UpperCamelCase__	=     input('Enter numbers separated by comma:\n').strip()
 UpperCamelCase__	=     [int(item) for item in user_input.split(',')]

 UpperCamelCase__	=     input('Enter a single number to be found in the list:\n')
 UpperCamelCase__	=     int(target_input)
 UpperCamelCase__	=     sentinel_linear_search(sequence, target)
 if result is not None:
  print(f"""{target} found at positions: {result}""")
 else:
  print('Not found')




