

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

def 						__SCREAMING_SNAKE_CASE						(   A_				):
 lowerCAmelCase__			:		Optional[Any]						       =			pkg_resources.read_text(A_		,  A_				)
 return yaml.safe_load(A_				), f'{BASE_REF_URL}/resources/{resource}'


__UpperCamelCase						:   Tuple							   =	load_yaml_resource('''readme_structure.yaml''')

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







class        SCREAMING_SNAKE_CASE      :






     """simple docstring"""



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







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

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

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







     def  __lowerCAmelCase				( self    :       str     ,lowercase_    :       dict	):
      lowerCAmelCase__			:		List[Any]						       =			[]
      lowerCAmelCase__			:		List[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
        lowerCAmelCase__			:		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
        lowerCAmelCase__			:		Tuple						       =			[subsection['''name'''] for subsection in structure['''subsections''']]
        lowerCAmelCase__			:		int						       =			False
        for idx, name in enumerate(lowercase_	):
         if name not in self.content:
          # If the expected subsection is not present
          error_list.append(F'Section `{self.name}` is missing subsection: `{name}`.'	)
          lowerCAmelCase__			:		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:
           lowerCAmelCase__			:		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  __lowerCAmelCase				( self    :       List[str]	):
      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        SCREAMING_SNAKE_CASE      (	a_ ):  # Level 0






     """simple docstring"""



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







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







     @classmethod
     def  __lowerCAmelCase				( cls    :       Optional[Any]     ,lowercase_    :       Path     ,lowercase_    :       dict = None     ,lowercase_    :       bool = False	):
      with open(lowercase_     ,encoding='''utf-8'''	) as f:
       lowerCAmelCase__			:		Dict						       =			f.readlines()
      return cls(lowercase_     ,lowercase_     ,lowercase_     ,suppress_parsing_errors=lowercase_	)







     @classmethod
     def  __lowerCAmelCase				( cls    :       Union[str, Any]     ,lowercase_    :       str     ,lowercase_    :       dict = None     ,lowercase_    :       str = "root"     ,lowercase_    :       bool = False	):
      lowerCAmelCase__			:		Optional[Any]						       =			string.split('''\n'''	)
      return cls(lowercase_     ,lowercase_     ,lowercase_     ,suppress_parsing_errors=lowercase_	)







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







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







     def  __lowerCAmelCase				( self    :       Optional[int]     ,lowercase_    :       Tuple	):
      lowerCAmelCase__			:		Union[str, Any]						       =			[]
      lowerCAmelCase__			:		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.
      lowerCAmelCase__			:		Tuple						       =			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
       lowerCAmelCase__			:		Tuple						       =			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
        lowerCAmelCase__			:		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

       __UpperCamelCase						:   Dict							   =	ArgumentParser(usage='''Validate the content (excluding YAML tags) of a README.md file.''')
       ap.add_argument('''readme_filepath''')
       __UpperCamelCase						:   Optional[int]							   =	ap.parse_args()
       __UpperCamelCase						:   List[Any]							   =	Path(args.readme_filepath)
       __UpperCamelCase						:   str							   =	ReadMe.from_readme(readme_filepath)







"""simple docstring"""





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import SwinaSRImageProcessor
							from transformers.image_transforms import get_image_size







class        SCREAMING_SNAKE_CASE      (	unittest.TestCase ):






					"""simple docstring"""



					def __init__( self    :       Dict     ,lowercase_    :       List[str]     ,lowercase_    :       List[str]=7     ,lowercase_    :       List[Any]=3     ,lowercase_    :       str=1_8     ,lowercase_    :       Any=3_0     ,lowercase_    :       int=4_0_0     ,lowercase_    :       Tuple=True     ,lowercase_    :       Optional[int]=1 / 2_5_5     ,lowercase_    :       int=True     ,lowercase_    :       Union[str, Any]=8     ,):
						lowerCAmelCase__			:		Tuple						       =			parent
						lowerCAmelCase__			:		Optional[Any]						       =			batch_size
						lowerCAmelCase__			:		int						       =			num_channels
						lowerCAmelCase__			:		Union[str, Any]						       =			image_size
						lowerCAmelCase__			:		Optional[Any]						       =			min_resolution
						lowerCAmelCase__			:		Union[str, Any]						       =			max_resolution
						lowerCAmelCase__			:		int						       =			do_rescale
						lowerCAmelCase__			:		Tuple						       =			rescale_factor
						lowerCAmelCase__			:		Dict						       =			do_pad
						lowerCAmelCase__			:		str						       =			pad_size







					def  __lowerCAmelCase				( self    :       int	):
						return {
						    "do_rescale": self.do_rescale,
						    "rescale_factor": self.rescale_factor,
						    "do_pad": self.do_pad,
						    "pad_size": self.pad_size,
						}







					def  __lowerCAmelCase				( self    :       Union[str, Any]     ,lowercase_    :       List[str]=False     ,lowercase_    :       Any=False     ,lowercase_    :       Dict=False	):
						assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

						if equal_resolution:
							lowerCAmelCase__			:		int						       =			[]
							for i in range(self.batch_size	):
								image_inputs.append(
								    np.random.randint(
								        2_5_5     ,size=(self.num_channels, self.max_resolution, self.max_resolution)     ,dtype=np.uinta	)	)
						else:
							lowerCAmelCase__			:		str						       =			[]
							for i in range(self.batch_size	):
								lowerCAmelCase__       ,lowerCAmelCase__			:		Any						       =			np.random.choice(np.arange(self.min_resolution     ,self.max_resolution	)     ,2	)
								image_inputs.append(np.random.randint(2_5_5     ,size=(self.num_channels, width, height)     ,dtype=np.uinta	)	)

						if not numpify and not torchify:
							# PIL expects the channel dimension as last dimension
							lowerCAmelCase__			:		Optional[int]						       =			[Image.fromarray(np.moveaxis(lowercase_     ,0     ,-1	)	) for x in image_inputs]

						if torchify:
							lowerCAmelCase__			:		int						       =			[torch.from_numpy(lowercase_	) for x in image_inputs]

						return image_inputs







@require_torch
@require_vision
class        SCREAMING_SNAKE_CASE      (	a_					,							unittest.TestCase ):






					"""simple docstring"""



					lowercase__       				= SwinaSRImageProcessor if is_vision_available() else None







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__			:		Dict						       =			SwinaSRImageProcessingTester(self	)







					@property
					def  __lowerCAmelCase				( self    :       str	):
						return self.image_processor_tester.prepare_image_processor_dict()







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__			:		Any						       =			self.image_processing_class(**self.image_processor_dict	)
						self.assertTrue(hasattr(lowercase_     ,'''do_rescale'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''rescale_factor'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''do_pad'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''pad_size'''	)	)







					def  __lowerCAmelCase				( self    :       Dict	):
						pass







					def  __lowerCAmelCase				( self    :       List[str]     ,lowercase_    :       Optional[Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Tuple						       =			get_image_size(lowercase_	)
						lowerCAmelCase__			:		Dict						       =			self.image_processor_tester.pad_size

						lowerCAmelCase__			:		List[Any]						       =			(old_height // size + 1) * size - old_height
						lowerCAmelCase__			:		Union[str, Any]						       =			(old_width // size + 1) * size - old_width
						return old_height + pad_height, old_width + pad_width







					def  __lowerCAmelCase				( self    :       List[Any]	):
						# Initialize image_processor
						lowerCAmelCase__			:		str						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random PIL images
						lowerCAmelCase__			:		int						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,Image.Image	)

						# Test not batched input
						lowerCAmelCase__			:		List[str]						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[Any]						       =			self.calculate_expected_size(np.array(image_inputs[0]	)	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)







					def  __lowerCAmelCase				( self    :       int	):
						# Initialize image_processor
						lowerCAmelCase__			:		str						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random numpy tensors
						lowerCAmelCase__			:		Tuple						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_     ,numpify=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,np.ndarray	)

						# Test not batched input
						lowerCAmelCase__			:		Optional[Any]						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[Any]						       =			self.calculate_expected_size(image_inputs[0]	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)







					def  __lowerCAmelCase				( self    :       Dict	):
						# Initialize image_processor
						lowerCAmelCase__			:		Tuple						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random PyTorch tensors
						lowerCAmelCase__			:		Union[str, Any]						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_     ,torchify=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,torch.Tensor	)

						# Test not batched input
						lowerCAmelCase__			:		Tuple						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		int						       =			self.calculate_expected_size(image_inputs[0]	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)




