


"""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 	lowercase__							(						self		,					snake_case__						):






         """simple docstring"""





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







       def 	lowercase__							(						self		,					snake_case__		,					snake_case__=False						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							super().construct_mapping(snake_case__		,					deep=snake_case__						)
         self._check_no_duplicates_on_constructed_node(snake_case__						)
         return mapping

def  a__      (    SCREAMING_SNAKE_CASE   :   str    ):


  '''simple docstring'''







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

  return None, "\n".join(SCREAMING_SNAKE_CASE    )


class 				SCREAMING_SNAKE_CASE__    (		lowercase    ):
       """simple docstring"""


       a  :    int       ={"train_eval_index"}  # train-eval-index in the YAML metadata

       @classmethod
       def 	lowercase__							(						cls		,					snake_case__						):






         """simple docstring"""





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

       def 	lowercase__							(						self		,					snake_case__						):






         """simple docstring"""





         if path.exists():
           with open(snake_case__		,					encoding="utf-8"						) as readme_file:
             lowerCAmelCase					:					Tuple								=							readme_file.read()
         else:
           lowerCAmelCase					:					List[Any]								=							None
         lowerCAmelCase					:					List[str]								=							self._to_readme(snake_case__						)
         with open(snake_case__		,					"w"		,					encoding="utf-8"						) as readme_file:
           readme_file.write(snake_case__						)

       def 	lowercase__							(						self		,					snake_case__ = None						):






         """simple docstring"""





         if readme_content is not None:
           lowerCAmelCase						,  lowerCAmelCase					:					List[Any]								=							_split_yaml_from_readme(snake_case__						)
           lowerCAmelCase					:					int								=							"---\n" + self.to_yaml_string() + "---\n" + content
         else:
           lowerCAmelCase					:					List[Any]								=							"---\n" + self.to_yaml_string() + "---\n"
         return full_content

       @classmethod
       def 	lowercase__							(						cls		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							yaml.load(snake_case__		,					Loader=_NoDuplicateSafeLoader						) or {}

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







       def 	lowercase__							(						self						):






         """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=snake_case__		,					allow_unicode=snake_case__		,					encoding="utf-8"		,					).decode("utf-8"						)

lowerCAmelCase__				    =       {
    '''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__				    =       ArgumentParser(usage='''Validate the yaml metadata block of a README.md file.''')
     ap.add_argument('''readme_filepath''')
     lowerCAmelCase__				    =       ap.parse_args()

     lowerCAmelCase__				    =       Path(args.readme_filepath)
     lowerCAmelCase__				    =       DatasetMetadata.from_readme(readme_filepath)
     print(dataset_metadata)
     dataset_metadata.to_readme(readme_filepath)









"""simple docstring"""







import pytest

from datasets.parallel import ParallelBackendConfig, parallel_backend
from datasets.utils.py_utils import map_nested

from .utils import require_dill_gt_0_3_2, require_joblibspark, require_not_windows
def  a__      (    SCREAMING_SNAKE_CASE   :   str    ):  # picklable for multiprocessing


  '''simple docstring'''







  return i + 1
@require_dill_gt_0_3_2
@require_joblibspark
@require_not_windows
def  a__      (    ):


  '''simple docstring'''







  with parallel_backend("spark"    ):
    assert ParallelBackendConfig.backend_name == "spark"

  lowerCAmelCase					:					List[str]								=							[1, 2, 3]
  with pytest.raises(SCREAMING_SNAKE_CASE    ):
    with parallel_backend("unsupported backend"    ):
      map_nested(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				num_proc=2    )

  with pytest.raises(SCREAMING_SNAKE_CASE    ):
    with parallel_backend("unsupported backend"    ):
      map_nested(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				num_proc=-1    )





@require_dill_gt_0_3_2
@require_joblibspark
@require_not_windows
@pytest.mark.parametrize("num_proc"    ,				[2, -1]    )
def  a__      (    SCREAMING_SNAKE_CASE   :   Tuple    ):


  '''simple docstring'''







  lowerCAmelCase					:					Tuple								=							[1, 2]
  lowerCAmelCase					:					int								=							{"a": 1, "b": 2}
  lowerCAmelCase					:					List[str]								=							{"a": [1, 2], "b": [3, 4]}
  lowerCAmelCase					:					Dict								=							{"a": {"1": 1}, "b": 2}
  lowerCAmelCase					:					Tuple								=							{"a": 1, "b": 2, "c": 3, "d": 4}
  lowerCAmelCase					:					Any								=							[2, 3]
  lowerCAmelCase					:					Any								=							{"a": 2, "b": 3}
  lowerCAmelCase					:					Optional[int]								=							{"a": [2, 3], "b": [4, 5]}
  lowerCAmelCase					:					Optional[int]								=							{"a": {"1": 2}, "b": 3}
  lowerCAmelCase					:					str								=							{"a": 2, "b": 3, "c": 4, "d": 5}

  with parallel_backend("spark"    ):
    assert map_nested(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				num_proc=SCREAMING_SNAKE_CASE    ) == expected_map_nested_sa
    assert map_nested(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				num_proc=SCREAMING_SNAKE_CASE    ) == expected_map_nested_sa
    assert map_nested(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				num_proc=SCREAMING_SNAKE_CASE    ) == expected_map_nested_sa
    assert map_nested(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				num_proc=SCREAMING_SNAKE_CASE    ) == expected_map_nested_sa
    assert map_nested(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				num_proc=SCREAMING_SNAKE_CASE    ) == expected_map_nested_sa





