






"""simple docstring"""



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      _lowerCAmelCase		(							UpperCAmelCase__       :					Optional[Any],						UpperCAmelCase__       :					Tuple      )		->Any:
						A__						:  Optional[Any]		  =  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[Any]		  =  DatasetInfosDict.from_directory(UpperCAmelCase__      )
						assert dataset_infos
						assert dataset_infos["default"].dataset_size == 4_2




@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=4_2,						),
    ],						)
def      _lowerCAmelCase		(							UpperCAmelCase__       :					List[Any],						UpperCAmelCase__       :					DatasetInfo      )		->str:
						A__						:  Dict		  =  str(UpperCAmelCase__      )
						dataset_info.write_to_directory(UpperCAmelCase__      )
						A__						:  Tuple		  =  DatasetInfo.from_directory(UpperCAmelCase__      )
						assert dataset_info == reloaded
						assert os.path.exists(os.path.join(UpperCAmelCase__,						"""dataset_info.json"""      )      )




def      _lowerCAmelCase		(							)		->Optional[int]:
						A__						:  Dict		  =  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""": 4_2}],						download_checksums={},						download_size=1_3_3_7,						post_processing_size=4_4_2,						dataset_size=1_2_3_4,						size_in_bytes=1_3_3_7 + 4_4_2 + 1_2_3_4,						)
						A__						:  int		  =  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__						:  List[Any]		  =  yaml.safe_dump(UpperCAmelCase__      )
						A__						:  Dict		  =  yaml.safe_load(UpperCAmelCase__      )
						assert dataset_info_yaml_dict == reloaded




def      _lowerCAmelCase		(							)		->str:
						A__						:  Any		  =  DatasetInfo()
						A__						:  Dict		  =  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=4_2,						)
            }      ),
        DatasetInfosDict(
            {
                """v1""": DatasetInfo(dataset_size=4_2      ),
                """v2""": DatasetInfo(dataset_size=1_3_3_7      ),
            }      ),
    ],						)
def      _lowerCAmelCase		(							UpperCAmelCase__       :					Dict,						UpperCAmelCase__       :					DatasetInfosDict      )		->Optional[Any]:
						A__						:  Dict		  =  str(UpperCAmelCase__      )
						dataset_infos_dict.write_to_directory(UpperCAmelCase__      )
						A__						:  int		  =  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__						:  int		  =  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__						:  Any		  =  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"""      )      )














"""simple docstring"""



def      _lowerCAmelCase		(							UpperCAmelCase__       :					str,						UpperCAmelCase__       :					List[Any]      )		->List[Any]:
						A__						:  Union[str, Any]		  =  [1]
						for i in range(2,						UpperCAmelCase__      ):
												factorials.append(factorials[-1] * i      )
						assert 0 <= k < factorials[-1] * n, "k out of bounds"

						A__						:  Optional[int]		  =  []
						A__						:  List[str]		  =  list(range(UpperCAmelCase__      )      )

						# Find permutation
						while factorials:
												A__						:  Optional[int]		  =  factorials.pop()
												A__  ,  A__						:  Optional[int]		  =  divmod(UpperCAmelCase__,						UpperCAmelCase__      )
												permutation.append(elements[number]      )
												elements.remove(elements[number]      )
						permutation.append(elements[0]      )

						return permutation


if __name__ == "__main__":
						import doctest

						doctest.testmod()






