




'''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__     :  Tuple    					=			'https://github.com/huggingface/datasets/tree/main/src/datasets/utils'
lowercase__     :  int    					=			F'''{BASE_REF_URL}/{__file__}'''
lowercase__     :  Dict    					=			logging.getLogger(__name__)





def 						snake_case__ (lowerCAmelCase_	):
    UpperCamelCase__      =			pkg_resources.read_text(lowerCAmelCase_					,  lowerCAmelCase_	)
    return yaml.safe_load(lowerCAmelCase_	), F'{BASE_REF_URL}/resources/{resource}'


lowercase__     :  int    					=			load_yaml_resource('readme_structure.yaml')

lowercase__     :  Tuple    					=			[
    '[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__     :  Optional[Any]    					=			Tuple[dict, List[str], List[str]]

class       lowerCamelCase_							:






   '''simple docstring'''

   def __init__(  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase = None     ,						__UpperCamelCase = False ):
       UpperCamelCase__      =			name
       UpperCamelCase__      =			level
       UpperCamelCase__      =			lines
       UpperCamelCase__      =			""
       UpperCamelCase__      =			True
       UpperCamelCase__      =			{}
       UpperCamelCase__      =			[]
       UpperCamelCase__      =			[]
       if self.lines is not None:
           self.parse(suppress_parsing_errors=__UpperCamelCase )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase = False ):
       UpperCamelCase__      =			""
       UpperCamelCase__      =			[]
       UpperCamelCase__      =			False
       for line in self.lines:
           if line.strip(" \n" ) == "":
               continue
           elif line.strip(" \n" )[:3] == "```":
               UpperCamelCase__      =			not code_start
           elif line.split()[0] == self.level + "#" and not code_start:
               if current_sub_level != "":
                   UpperCamelCase__      =			Section(__UpperCamelCase     ,						self.level + "#"     ,						__UpperCamelCase )
                   UpperCamelCase__      =			[]
               else:
                   if current_lines != []:
                       self.text += "".join(__UpperCamelCase ).strip()
                       if self.text != "" and self.text not in FILLER_TEXT:
                           UpperCamelCase__      =			False
                       UpperCamelCase__      =			[]

               UpperCamelCase__      =			" ".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.' )
               UpperCamelCase__      =			Section(__UpperCamelCase     ,						self.level + "#"     ,						__UpperCamelCase )
           else:
               if current_lines != []:
                   self.text += "".join(__UpperCamelCase ).strip()
                   if self.text != "" and self.text not in FILLER_TEXT:
                       UpperCamelCase__      =			False

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


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase ):
       UpperCamelCase__      =			[]
       UpperCamelCase__      =			[]
       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
               UpperCamelCase__      =			[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
               UpperCamelCase__      =			[subsection["name"] for subsection in structure["subsections"]]
               UpperCamelCase__      =			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}`.' )
                       UpperCamelCase__      =			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:
                           UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__      =			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 ):
       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






   '''simple docstring'''

   def __init__(  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase = None     ,						__UpperCamelCase = False ):
       super().__init__(name=__UpperCamelCase     ,						level="" )  # Not using lines here as we need to use a child class parse
       UpperCamelCase__      =			structure
       UpperCamelCase__      =			-2
       UpperCamelCase__      =			0
       UpperCamelCase__      =			lines
       if self.lines is not None:
           self.parse(suppress_parsing_errors=__UpperCamelCase )


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


   @classmethod
   def 	_UpperCamelCase       (  cls     ,						__UpperCamelCase     ,						__UpperCamelCase = None     ,						__UpperCamelCase = False ):
       with open(__UpperCamelCase     ,						encoding="utf-8" ) as f:
           UpperCamelCase__      =			f.readlines()
       return cls(__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						suppress_parsing_errors=__UpperCamelCase )


   @classmethod
   def 	_UpperCamelCase       (  cls     ,						__UpperCamelCase     ,						__UpperCamelCase = None     ,						__UpperCamelCase = "root"     ,						__UpperCamelCase = False ):
       UpperCamelCase__      =			string.split("\n" )
       return cls(__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						suppress_parsing_errors=__UpperCamelCase )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase = False ):
       # Skip Tags
       UpperCamelCase__      =			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:
           UpperCamelCase__      =			self.lines[line_count + 1 :]  # Get the last + 1 th item.
       else:
           UpperCamelCase__      =			self.lines[self.tag_count :]
       super().parse(suppress_parsing_errors=__UpperCamelCase )


   def __str__(  self ):
       return str(self.to_dict() )







   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase ):
       UpperCamelCase__      =			[]
       UpperCamelCase__      =			[]
       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.
       UpperCamelCase__      =			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
           UpperCamelCase__      =			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
               UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__      =			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__     :  int    					=			ArgumentParser(usage='Validate the content (excluding YAML tags) of a README.md file.')
      ap.add_argument('readme_filepath')
      lowercase__     :  str    					=			ap.parse_args()
      lowercase__     :  Optional[Any]    					=			Path(args.readme_filepath)
      lowercase__     :  Optional[int]    					=			ReadMe.from_readme(readme_filepath)









'''simple docstring'''







import numpy as np  # noqa: E402

from ...configuration_utils import ConfigMixin, register_to_config
from ...schedulers.scheduling_utils import SchedulerMixin


try:
      import librosa  # noqa: E402

      lowercase__     :  Optional[Any]    					=			True
      lowercase__     :  int    					=			''
except Exception as e:
      lowercase__     :  Union[str, Any]    					=			False
      lowercase__     :  List[Any]    					=			(
          F'''Cannot import librosa because {e}. Make sure to correctly install librosa to be able to install it.'''
      )


from PIL import Image  # noqa: E402

class       lowerCamelCase_							(	lowerCAmelCase_					,    lowerCAmelCase_  ):






   '''simple docstring'''

   A :     int				=	"mel_config.json"


   @register_to_config
   def __init__(  self     ,						__UpperCamelCase = 2_56     ,						__UpperCamelCase = 2_56     ,						__UpperCamelCase = 2_20_50     ,						__UpperCamelCase = 20_48     ,						__UpperCamelCase = 5_12     ,						__UpperCamelCase = 80     ,						__UpperCamelCase = 32     ,						):
       UpperCamelCase__      =			hop_length
       UpperCamelCase__      =			sample_rate
       UpperCamelCase__      =			n_fft
       UpperCamelCase__      =			top_db
       UpperCamelCase__      =			n_iter
       self.set_resolution(__UpperCamelCase     ,						__UpperCamelCase )
       UpperCamelCase__      =			None

       if not _librosa_can_be_imported:
           raise ValueError(_import_error )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase ):
       UpperCamelCase__      =			x_res
       UpperCamelCase__      =			y_res
       UpperCamelCase__      =			self.y_res
       UpperCamelCase__      =			self.x_res * self.hop_length - 1


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase = None     ,						__UpperCamelCase = None ):
       if audio_file is not None:
           UpperCamelCase__    ,  UpperCamelCase__      =			librosa.load(__UpperCamelCase     ,						mono=__UpperCamelCase     ,						sr=self.sr )
       else:
           UpperCamelCase__      =			raw_audio

       # Pad with silence if necessary.
       if len(self.audio ) < self.x_res * self.hop_length:
           UpperCamelCase__      =			np.concatenate([self.audio, np.zeros((self.x_res * self.hop_length - len(self.audio ),) )] )


   def 	_UpperCamelCase       (  self ):
       return len(self.audio ) // self.slice_size


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase = 0 ):
       return self.audio[self.slice_size * slice : self.slice_size * (slice + 1)]


   def 	_UpperCamelCase       (  self ):
       return self.sr


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase ):
       UpperCamelCase__      =			librosa.feature.melspectrogram(
           y=self.get_audio_slice(__UpperCamelCase )     ,						sr=self.sr     ,						n_fft=self.n_fft     ,						hop_length=self.hop_length     ,						n_mels=self.n_mels )
       UpperCamelCase__      =			librosa.power_to_db(__UpperCamelCase     ,						ref=np.max     ,						top_db=self.top_db )
       UpperCamelCase__      =			(((log_S + self.top_db) * 2_55 / self.top_db).clip(0     ,						2_55 ) + 0.5).astype(np.uinta )
       UpperCamelCase__      =			Image.fromarray(__UpperCamelCase )
       return image







   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase ):
       UpperCamelCase__      =			np.frombuffer(image.tobytes()     ,						dtype="uint8" ).reshape((image.height, image.width) )
       UpperCamelCase__      =			bytedata.astype("float" ) * self.top_db / 2_55 - self.top_db
       UpperCamelCase__      =			librosa.db_to_power(__UpperCamelCase )
       UpperCamelCase__      =			librosa.feature.inverse.mel_to_audio(
           __UpperCamelCase     ,						sr=self.sr     ,						n_fft=self.n_fft     ,						hop_length=self.hop_length     ,						n_iter=self.n_iter )
       return audio




