






'''simple docstring'''


from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
					import PIL


lowerCamelCase_				: Optional[Any]    	=							logging.get_logger(__name__)
class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





			__a							:							Optional[Any]					     =					["pixel_values"]






			def __init__(   self							:						List[str] ,      lowercase							:						bool = True ,      lowercase							:						Dict[str, int] = None ,      lowercase							:						PILImageResampling = PIL.Image.BICUBIC ,      lowercase							:						bool = True ,      lowercase							:						Dict[str, int] = None ,      lowercase							:						Union[int, float] = 1 / 2_5_5 ,      lowercase							:						bool = True ,      lowercase							:						bool = True ,      lowercase							:						Optional[Union[float, List[float]]] = None ,      lowercase							:						Optional[Union[float, List[float]]] = None ,      **lowercase							:						Optional[Any] ,      )							->    None:

									'''simple docstring'''







									super().__init__(**lowercase			)
									UpperCamelCase__         = size if size is not None else {"""height""": 2_5_6, """width""": 2_5_6}
									UpperCamelCase__         = get_size_dict(lowercase			)
									UpperCamelCase__         = crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
									UpperCamelCase__         = get_size_dict(lowercase ,      param_name="""crop_size"""			)

									UpperCamelCase__         = do_resize
									UpperCamelCase__         = size
									UpperCamelCase__         = resample
									UpperCamelCase__         = do_center_crop
									UpperCamelCase__         = crop_size
									UpperCamelCase__         = do_rescale
									UpperCamelCase__         = rescale_factor
									UpperCamelCase__         = do_normalize
									UpperCamelCase__         = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
									UpperCamelCase__         = image_std if image_std is not None else IMAGENET_STANDARD_STD






			def 				A      (   self							:						Union[str, Any] ,      lowercase							:						np.ndarray ,      lowercase							:						Dict[str, int] ,      lowercase							:						PILImageResampling = PIL.Image.BICUBIC ,      lowercase							:						Optional[Union[str, ChannelDimension]] = None ,      **lowercase							:						Dict ,      )							->    np.ndarray:

									'''simple docstring'''







									UpperCamelCase__         = get_size_dict(lowercase			)
									if "height" not in size or "width" not in size:
															raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"			)
									return resize(
									    lowercase ,      size=(size["""height"""], size["""width"""]) ,      resample=lowercase ,      data_format=lowercase ,      **lowercase			)






			def 				A      (   self							:						str ,      lowercase							:						np.ndarray ,      lowercase							:						Dict[str, int] ,      lowercase							:						Optional[Union[str, ChannelDimension]] = None ,      **lowercase							:						Tuple ,      )							->    np.ndarray:

									'''simple docstring'''







									UpperCamelCase__         = get_size_dict(lowercase			)
									if "height" not in size or "width" not in size:
															raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"			)
									return center_crop(lowercase ,      size=(size["""height"""], size["""width"""]) ,      data_format=lowercase ,      **lowercase			)






			def 				A      (   self							:						Optional[int] ,      lowercase							:						np.ndarray ,      lowercase							:						Union[int, float] ,      lowercase							:						Optional[Union[str, ChannelDimension]] = None ,      **lowercase							:						Optional[int] ,      )							->    List[Any]:

									'''simple docstring'''







									return rescale(lowercase ,      scale=lowercase ,      data_format=lowercase ,      **lowercase			)






			def 				A      (   self							:						List[Any] ,      lowercase							:						np.ndarray ,      lowercase							:						Union[float, List[float]] ,      lowercase							:						Union[float, List[float]] ,      lowercase							:						Optional[Union[str, ChannelDimension]] = None ,      **lowercase							:						str ,      )							->    np.ndarray:

									'''simple docstring'''







									return normalize(lowercase ,      mean=lowercase ,      std=lowercase ,      data_format=lowercase ,      **lowercase			)







			def 				A      (   self							:						Optional[Any] ,      lowercase							:						ImageInput ,      lowercase							:						bool = None ,      lowercase							:						Dict[str, int] = None ,      lowercase							:						Optional[Any]=None ,      lowercase							:						bool = None ,      lowercase							:						Dict[str, int] = None ,      lowercase							:						bool = None ,      lowercase							:						float = None ,      lowercase							:						bool = None ,      lowercase							:						Optional[Union[float, List[float]]] = None ,      lowercase							:						Optional[Union[float, List[float]]] = None ,      lowercase							:						Optional[Union[str, TensorType]] = None ,      lowercase							:						ChannelDimension = ChannelDimension.FIRST ,      **lowercase							:						Optional[Any] ,      )							->    PIL.Image.Image:

									'''simple docstring'''







									UpperCamelCase__         = do_resize if do_resize is not None else self.do_resize
									UpperCamelCase__         = resample if resample is not None else self.resample
									UpperCamelCase__         = do_center_crop if do_center_crop is not None else self.do_center_crop
									UpperCamelCase__         = do_rescale if do_rescale is not None else self.do_rescale
									UpperCamelCase__         = rescale_factor if rescale_factor is not None else self.rescale_factor
									UpperCamelCase__         = do_normalize if do_normalize is not None else self.do_normalize
									UpperCamelCase__         = image_mean if image_mean is not None else self.image_mean
									UpperCamelCase__         = image_std if image_std is not None else self.image_std

									UpperCamelCase__         = size if size is not None else self.size
									UpperCamelCase__         = get_size_dict(lowercase			)
									UpperCamelCase__         = crop_size if crop_size is not None else self.crop_size
									UpperCamelCase__         = get_size_dict(lowercase ,      param_name="""crop_size"""			)

									UpperCamelCase__         = make_list_of_images(lowercase			)

									if not valid_images(lowercase			):
															raise ValueError(
															    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
															    """torch.Tensor, tf.Tensor or jax.ndarray."""			)

									if do_resize and size is None or resample is None:
															raise ValueError("""Size and resample must be specified if do_resize is True."""			)

									if do_center_crop and crop_size is None:
															raise ValueError("""Crop size must be specified if do_center_crop is True."""			)

									if do_rescale and rescale_factor is None:
															raise ValueError("""Rescale factor must be specified if do_rescale is True."""			)

									if do_normalize and (image_mean is None or image_std is None):
															raise ValueError("""Image mean and std must be specified if do_normalize is True."""			)

									# All transformations expect numpy arrays.
									UpperCamelCase__         = [to_numpy_array(lowercase			) for image in images]

									if do_resize:
															UpperCamelCase__         = [self.resize(image=lowercase ,      size=lowercase ,      resample=lowercase			) for image in images]

									if do_center_crop:
															UpperCamelCase__         = [self.center_crop(image=lowercase ,      size=lowercase			) for image in images]

									if do_rescale:
															UpperCamelCase__         = [self.rescale(image=lowercase ,      scale=lowercase			) for image in images]

									if do_normalize:
															UpperCamelCase__         = [self.normalize(image=lowercase ,      mean=lowercase ,      std=lowercase			) for image in images]

									UpperCamelCase__         = [to_channel_dimension_format(lowercase ,      lowercase			) for image in images]

									UpperCamelCase__         = {"""pixel_values""": images}
									return BatchFeature(data=lowercase ,      tensor_type=lowercase			)








'''simple docstring'''


from collections import Counter
from pathlib import Path
from typing import Optional, Tuple

import yaml
class    _SCREAMING_SNAKE_CASE							(		yaml.SafeLoader	):


			'''simple docstring'''





			def 				A      (   self							:						List[str] ,      lowercase							:						List[Any]			)							->    int:

									'''simple docstring'''







									UpperCamelCase__         = [self.constructed_objects[key_node] for key_node, _ in node.value]
									UpperCamelCase__         = [tuple(lowercase			) if isinstance(lowercase ,      lowercase			) else key for key in keys]
									UpperCamelCase__         = Counter(lowercase			)
									UpperCamelCase__         = [key for key in counter if counter[key] > 1]
									if duplicate_keys:
															raise TypeError(f"Got duplicate yaml keys: {duplicate_keys}"			)







			def 				A      (   self							:						List[str] ,      lowercase							:						int ,      lowercase							:						str=False			)							->    Any:

									'''simple docstring'''







									UpperCamelCase__         = super().construct_mapping(lowercase ,      deep=lowercase			)
									self._check_no_duplicates_on_constructed_node(lowercase			)
									return mapping







def 	__magic_name__( _A					):
						'''simple docstring'''





						UpperCamelCase__         = list(readme_content.splitlines()					)
						if full_content and full_content[0] == "---" and "---" in full_content[1:]:
												UpperCamelCase__         = full_content[1:].index("""---"""					) + 1
												UpperCamelCase__         = """\n""".join(full_content[1:sep_idx]					)
												return yamlblock, "\n".join(full_content[sep_idx + 1 :]					)

						return None, "\n".join(_A					)
class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





			__a							:							Tuple					     =					{"train_eval_index"}  # train-eval-index in the YAML metadata






			@classmethod
			def 				A      (   cls							:						int ,      lowercase							:						Path			)							->    "DatasetMetadata":

									'''simple docstring'''







									with open(lowercase ,      encoding="""utf-8"""			) as readme_file:
															UpperCamelCase__    ,   UpperCamelCase__         = _split_yaml_from_readme(readme_file.read()			)
									if yaml_string is not None:
															return cls.from_yaml_string(lowercase			)
									else:
															return cls()






			def 				A      (   self							:						int ,      lowercase							:						Path			)							->    Dict:

									'''simple docstring'''







									if path.exists():
															with open(lowercase ,      encoding="""utf-8"""			) as readme_file:
																					UpperCamelCase__         = readme_file.read()
									else:
															UpperCamelCase__         = None
									UpperCamelCase__         = self._to_readme(lowercase			)
									with open(lowercase ,      """w""" ,      encoding="""utf-8"""			) as readme_file:
															readme_file.write(lowercase			)






			def 				A      (   self							:						Any ,      lowercase							:						Optional[str] = None			)							->    str:

									'''simple docstring'''







									if readme_content is not None:
															UpperCamelCase__    ,   UpperCamelCase__         = _split_yaml_from_readme(lowercase			)
															UpperCamelCase__         = """---\n""" + self.to_yaml_string() + """---\n""" + content
									else:
															UpperCamelCase__         = """---\n""" + self.to_yaml_string() + """---\n"""
									return full_content






			@classmethod
			def 				A      (   cls							:						Tuple ,      lowercase							:						str			)							->    "DatasetMetadata":

									'''simple docstring'''







									UpperCamelCase__         = yaml.load(lowercase ,      Loader=_NoDuplicateSafeLoader			) or {}

									# Convert the YAML keys to DatasetMetadata fields
									UpperCamelCase__         = {
									    (key.replace("""-""" ,      """_"""			) if key.replace("""-""" ,      """_"""			) in cls._FIELDS_WITH_DASHES else key): value
									    for key, value in metadata_dict.items()
									}
									return cls(**lowercase			)







			def 				A      (   self							:						Dict			)							->    str:

									'''simple docstring'''







									return yaml.safe_dump(
									    {
									        (key.replace("""_""" ,      """-"""			) if key in self._FIELDS_WITH_DASHES else key): value
									        for key, value in self.items()
									    } ,      sort_keys=lowercase ,      allow_unicode=lowercase ,      encoding="""utf-8""" ,      ).decode("""utf-8"""			)
lowerCamelCase_				: str    	=							{
    '''image-classification''': [],
    '''translation''': [],
    '''image-segmentation''': [],
    '''fill-mask''': [],
    '''automatic-speech-recognition''': [],
    '''token-classification''': [],
    '''sentence-similarity''': [],
    '''audio-classification''': [],
    '''question-answering''': [],
    '''summarization''': [],
    '''zero-shot-classification''': [],
    '''table-to-text''': [],
    '''feature-extraction''': [],
    '''other''': [],
    '''multiple-choice''': [],
    '''text-classification''': [],
    '''text-to-image''': [],
    '''text2text-generation''': [],
    '''zero-shot-image-classification''': [],
    '''tabular-classification''': [],
    '''tabular-regression''': [],
    '''image-to-image''': [],
    '''tabular-to-text''': [],
    '''unconditional-image-generation''': [],
    '''text-retrieval''': [],
    '''text-to-speech''': [],
    '''object-detection''': [],
    '''audio-to-audio''': [],
    '''text-generation''': [],
    '''conversational''': [],
    '''table-question-answering''': [],
    '''visual-question-answering''': [],
    '''image-to-text''': [],
    '''reinforcement-learning''': [],
    '''voice-activity-detection''': [],
    '''time-series-forecasting''': [],
    '''document-question-answering''': [],
}


if __name__ == "__main__":
					from argparse import ArgumentParser

					lowerCamelCase_				: Tuple    	=							ArgumentParser(usage='''Validate the yaml metadata block of a README.md file.''')
					ap.add_argument('''readme_filepath''')
					lowerCamelCase_				: str    	=							ap.parse_args()

					lowerCamelCase_				: List[str]    	=							Path(args.readme_filepath)
					lowerCamelCase_				: Tuple    	=							DatasetMetadata.from_readme(readme_filepath)
					print(dataset_metadata)
					dataset_metadata.to_readme(readme_filepath)
