





import os

import pytest
import yaml

from datasets.features.features import Features, Value
from datasets.info import DatasetInfo, DatasetInfosDict







@pytest.mark.parametrize(
    'files'   ,		[
        ['full:README.md', 'dataset_infos.json'],
        ['empty:README.md', 'dataset_infos.json'],
        ['dataset_infos.json'],
        ['full:README.md'],
    ]   ,		)
def 					_SCREAMING_SNAKE_CASE							(  a   ,		a    ) -> Any:
					__A      :		int         =							tmp_path_factory.mktemp('dset_infos_dir'    )
					if "full:README.md" in files:
										with open(dataset_infos_dir / 'README.md'   ,		'w'    ) as f:
															f.write('---\ndataset_info:\n  dataset_size: 42\n---'    )
					if "empty:README.md" in files:
										with open(dataset_infos_dir / 'README.md'   ,		'w'    ) as f:
															f.write(''    )
    # we want to support dataset_infos.json for backward compatibility
					if "dataset_infos.json" in files:
										with open(dataset_infos_dir / 'dataset_infos.json'   ,		'w'    ) as f:
															f.write('{\"default\": {\"dataset_size\": 42}}'    )
					__A      :		List[str]         =							DatasetInfosDict.from_directory(UpperCAmelCase__    )
					assert dataset_infos
					assert dataset_infos["default"].dataset_size == 42







@pytest.mark.parametrize(
    'dataset_info'   ,		[
        DatasetInfo(),
        DatasetInfo(
            description='foo'   ,		features=Features({'a': Value('int32'    )}    )   ,		builder_name='builder'   ,		config_name='config'   ,		version='1.0.0'   ,		splits=[{'name': 'train'}]   ,		download_size=42   ,		),
    ]   ,		)
def 					_SCREAMING_SNAKE_CASE							(  a   ,		a    ) -> Dict:
					__A      :		Optional[int]         =							str(UpperCAmelCase__    )
					dataset_info.write_to_directory(UpperCAmelCase__    )
					__A      :		List[Any]         =							DatasetInfo.from_directory(UpperCAmelCase__    )
					assert dataset_info == reloaded
					assert os.path.exists(os.path.join(UpperCAmelCase__   ,		'dataset_info.json'    )    )







def 					_SCREAMING_SNAKE_CASE							(  ) -> List[str]:
					__A      :		Any         =							DatasetInfo(
					    description='foo'   ,		citation='bar'   ,		homepage='https://foo.bar'   ,		license='CC0'   ,		features=Features({'a': Value('int32'    )}    )   ,		post_processed={}   ,		supervised_keys=()   ,		task_templates=[]   ,		builder_name='builder'   ,		config_name='config'   ,		version='1.0.0'   ,		splits=[{'name': 'train', 'num_examples': 42}]   ,		download_checksums={}   ,		download_size=13_37   ,		post_processing_size=4_42   ,		dataset_size=12_34   ,		size_in_bytes=13_37 + 4_42 + 12_34   ,		)
					__A      :		str         =							dataset_info._to_yaml_dict()
					assert sorted(UpperCAmelCase__    ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML    )
					for key in DatasetInfo._INCLUDED_INFO_IN_YAML:
										assert key in dataset_info_yaml_dict
										assert isinstance(dataset_info_yaml_dict[key]   ,		(list, dict, int, str)    )
					__A      :		Tuple         =							yaml.safe_dump(UpperCAmelCase__    )
					__A      :		Tuple         =							yaml.safe_load(UpperCAmelCase__    )
					assert dataset_info_yaml_dict == reloaded







def 					_SCREAMING_SNAKE_CASE							(  ) -> Any:
					__A      :		Any         =							DatasetInfo()
					__A      :		int         =							dataset_info._to_yaml_dict()
					assert dataset_info_yaml_dict == {}







@pytest.mark.parametrize(
    'dataset_infos_dict'   ,		[
        DatasetInfosDict(),
        DatasetInfosDict({'default': DatasetInfo()}    ),
        DatasetInfosDict({'my_config_name': DatasetInfo()}    ),
        DatasetInfosDict(
            {
                'default': DatasetInfo(
                    description='foo'   ,		features=Features({'a': Value('int32'    )}    )   ,		builder_name='builder'   ,		config_name='config'   ,		version='1.0.0'   ,		splits=[{'name': 'train'}]   ,		download_size=42   ,		)
            }    ),
        DatasetInfosDict(
            {
                'v1': DatasetInfo(dataset_size=42    ),
                'v2': DatasetInfo(dataset_size=13_37    ),
            }    ),
    ]   ,		)
def 					_SCREAMING_SNAKE_CASE							(  a   ,		a    ) -> Optional[Any]:
					__A      :		int         =							str(UpperCAmelCase__    )
					dataset_infos_dict.write_to_directory(UpperCAmelCase__    )
					__A      :		List[str]         =							DatasetInfosDict.from_directory(UpperCAmelCase__    )

					# the config_name of the dataset_infos_dict take over the attribute
					for config_name, dataset_info in dataset_infos_dict.items():
										__A      :		str         =							config_name
										# the yaml representation doesn't include fields like description or citation
										# so we just test that we can recover what we can from the yaml
										__A      :		int         =							DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict()    )
					assert dataset_infos_dict == reloaded

					if dataset_infos_dict:
										assert os.path.exists(os.path.join(UpperCAmelCase__   ,		'README.md'    )    )






import os
import sys

lowercase   =	os.path.join(os.path.dirname(__file__), '''src''')
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


lowercase   =	[
    '''torch''',
    '''numpy''',
    '''tokenizers''',
    '''filelock''',
    '''requests''',
    '''tqdm''',
    '''regex''',
    '''sentencepiece''',
    '''sacremoses''',
    '''importlib_metadata''',
    '''huggingface_hub''',
]



@add_start_docstrings(AutoConfig.__doc__							)
def   __lowerCAmelCase    (				*UpperCAmelCase__					:   List[Any]      ,					**UpperCAmelCase__					:   List[str]							)	->     List[str]:
							return AutoConfig.from_pretrained(*UpperCAmelCase__      ,					**UpperCAmelCase__							)



@add_start_docstrings(AutoTokenizer.__doc__							)
def   __lowerCAmelCase    (				*UpperCAmelCase__					:   List[str]      ,					**UpperCAmelCase__					:   List[Any]							)	->     Any:
							return AutoTokenizer.from_pretrained(*UpperCAmelCase__      ,					**UpperCAmelCase__							)



@add_start_docstrings(AutoModel.__doc__							)
def   __lowerCAmelCase    (				*UpperCAmelCase__					:   Union[str, Any]      ,					**UpperCAmelCase__					:   Dict							)	->     Union[str, Any]:
							return AutoModel.from_pretrained(*UpperCAmelCase__      ,					**UpperCAmelCase__							)



@add_start_docstrings(AutoModelForCausalLM.__doc__							)
def   __lowerCAmelCase    (				*UpperCAmelCase__					:   List[str]      ,					**UpperCAmelCase__					:   List[Any]							)	->     Optional[Any]:
							return AutoModelForCausalLM.from_pretrained(*UpperCAmelCase__      ,					**UpperCAmelCase__							)



@add_start_docstrings(AutoModelForMaskedLM.__doc__							)
def   __lowerCAmelCase    (				*UpperCAmelCase__					:   Union[str, Any]      ,					**UpperCAmelCase__					:   Dict							)	->     int:
							return AutoModelForMaskedLM.from_pretrained(*UpperCAmelCase__      ,					**UpperCAmelCase__							)



@add_start_docstrings(AutoModelForSequenceClassification.__doc__							)
def   __lowerCAmelCase    (				*UpperCAmelCase__					:   List[Any]      ,					**UpperCAmelCase__					:   Dict							)	->     Dict:
							return AutoModelForSequenceClassification.from_pretrained(*UpperCAmelCase__      ,					**UpperCAmelCase__							)



@add_start_docstrings(AutoModelForQuestionAnswering.__doc__							)
def   __lowerCAmelCase    (				*UpperCAmelCase__					:   Any      ,					**UpperCAmelCase__					:   List[str]							)	->     Union[str, Any]:
							return AutoModelForQuestionAnswering.from_pretrained(*UpperCAmelCase__      ,					**UpperCAmelCase__							)





