






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 			=							'https://github.com/huggingface/datasets/tree/main/src/datasets/utils'
a 			=							F'{BASE_REF_URL}/{__file__}'
a 			=							logging.getLogger(__name__)
def    a__    (	A       ):
   lowercase__    :						Union[str, Any]       =			pkg_resources.read_text(A_		,					A_       )
   return yaml.safe_load(A_       ), F'''{BASE_REF_URL}/resources/{resource}'''


a 			=							load_yaml_resource('readme_structure.yaml')

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



 def __init__(						self : int			,		UpperCAmelCase__ : str			,		UpperCAmelCase__ : str			,		UpperCAmelCase__ : List[str] = None			,		UpperCAmelCase__ : bool = False						):

    """simple docstring"""






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



 def     UpperCAmelCase     (						self : Any			,		UpperCAmelCase__ : bool = False						):

    """simple docstring"""






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

          lowercase__    :						Optional[int]       =			' '.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.'''						)
          lowercase__    :						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:
                lowercase__    :						Tuple       =			False

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



 def     UpperCAmelCase     (						self : Tuple			,		UpperCAmelCase__ : dict						):

    """simple docstring"""






    lowercase__    :						int       =			[]
    lowercase__    :						Union[str, 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
          lowercase__    :						List[str]       =			[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__    :						Dict       =			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}`.'''						)
                lowercase__    :						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:
                   lowercase__    :						List[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 : 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 							__snake_case(       __UpperCamelCase   ):  # Level 0



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

    """simple docstring"""






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



 def     UpperCAmelCase     (						self : Tuple						):

    """simple docstring"""






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



 @classmethod
 def     UpperCAmelCase     (						cls : Any			,		UpperCAmelCase__ : Path			,		UpperCAmelCase__ : dict = None			,		UpperCAmelCase__ : bool = False						):

    """simple docstring"""






    with open(UpperCAmelCase__			,		encoding="""utf-8"""						) as f:
       lowercase__    :						Union[str, Any]       =			f.readlines()
    return cls(UpperCAmelCase__			,		UpperCAmelCase__			,		UpperCAmelCase__			,		suppress_parsing_errors=UpperCAmelCase__						)



 @classmethod
 def     UpperCAmelCase     (						cls : Union[str, Any]			,		UpperCAmelCase__ : str			,		UpperCAmelCase__ : dict = None			,		UpperCAmelCase__ : str = "root"			,		UpperCAmelCase__ : bool = False						):

    """simple docstring"""






    lowercase__    :						int       =			string.split("""\n"""						)
    return cls(UpperCAmelCase__			,		UpperCAmelCase__			,		UpperCAmelCase__			,		suppress_parsing_errors=UpperCAmelCase__						)



 def     UpperCAmelCase     (						self : Optional[int]			,		UpperCAmelCase__ : bool = False						):

    """simple docstring"""






    lowercase__    :						Union[str, 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__    :						Any       =			self.lines[line_count + 1 :]  # Get the last + 1 th item.
    else:
       lowercase__    :						Optional[Any]       =			self.lines[self.tag_count :]
    super().parse(suppress_parsing_errors=UpperCAmelCase__						)



 def __str__(						self : Tuple						):

    """simple docstring"""






    return str(self.to_dict()						)







 def     UpperCAmelCase     (						self : Dict			,		UpperCAmelCase__ : Tuple						):

    """simple docstring"""






    lowercase__    :						Optional[Any]       =			[]
    lowercase__    :						int       =			[]
    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[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__    :						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
          lowercase__    :						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

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










"""simple docstring"""


from __future__ import annotations




def      snake_case    (A_ :list[int | float]      ,     A_ :int      ,     A_ :int ):







  '''simple docstring'''

  if len(A_ ) == 0:
    raise ValueError('find_min() arg is an empty sequence' )
  if (
      left >= len(A_ )
      or left < -len(A_ )
      or right >= len(A_ )
      or right < -len(A_ )
  ):
    raise IndexError('list index out of range' )
  if left == right:
    return nums[left]
  a	:     Optional[Any]							=  (left + right) >> 1  # the middle
  a	:     List[str]							=  find_min(A_      ,     A_      ,     A_ )  # find min in range[left, mid]
  a	:     Union[str, Any]							=  find_min(A_      ,     mid + 1      ,     A_ )  # find min in range[mid + 1, right]

  return left_min if left_min <= right_min else right_min


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)




