
'''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 snake_case_     (					lowercase__   ,       lowercase__		):
  UpperCAmelCase__      :					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}}"		)
  UpperCAmelCase__      :					List[Any]				       =							DatasetInfosDict.from_directory(_lowercase		)
  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 snake_case_     (					lowercase__   ,       lowercase__		):
  UpperCAmelCase__      :					List[str]				       =							str(_lowercase		)
  dataset_info.write_to_directory(_lowercase		)
  UpperCAmelCase__      :					int				       =							DatasetInfo.from_directory(_lowercase		)
  assert dataset_info == reloaded
  assert os.path.exists(os.path.join(_lowercase   ,       "dataset_info.json"		)		)







def snake_case_     (					):
  UpperCAmelCase__      :					Tuple				       =							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   ,       )
  UpperCAmelCase__      :					List[str]				       =							dataset_info._to_yaml_dict()
  assert sorted(_lowercase		) == 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)		)
  UpperCAmelCase__      :					str				       =							yaml.safe_dump(_lowercase		)
  UpperCAmelCase__      :					List[Any]				       =							yaml.safe_load(_lowercase		)
  assert dataset_info_yaml_dict == reloaded







def snake_case_     (					):
  UpperCAmelCase__      :					Optional[int]				       =							DatasetInfo()
  UpperCAmelCase__      :					Union[str, Any]				       =							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 snake_case_     (					lowercase__   ,       lowercase__		):
  UpperCAmelCase__      :					Optional[int]				       =							str(_lowercase		)
  dataset_infos_dict.write_to_directory(_lowercase		)
  UpperCAmelCase__      :					Dict				       =							DatasetInfosDict.from_directory(_lowercase		)

  # the config_name of the dataset_infos_dict take over the attribute
  for config_name, dataset_info in dataset_infos_dict.items():
    UpperCAmelCase__      :					List[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
    UpperCAmelCase__      :					Optional[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(_lowercase   ,       "README.md"		)		)









__a							     =					'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'







def lowerCamelCase__  (     _lowercase ):

     '''simple docstring'''


     if not isinstance(_lowercase					,		_lowercase ):
          UpperCAmelCase_     :				Union[str, Any]  =     f'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
          raise TypeError(_lowercase )

     UpperCAmelCase_     :				Any  =     ''''''.join(bin(_lowercase )[2:].zfill(8 ) for byte in data )

     UpperCAmelCase_     :				Any  =     len(_lowercase ) % 6 != 0

     if padding_needed:
          # The padding that will be added later
          UpperCAmelCase_     :				Union[str, Any]  =     B'''=''' * ((6 - len(_lowercase ) % 6) // 2)

          # Append binary_stream with arbitrary binary digits (0's by default) to make its
          # length a multiple of 6.
          binary_stream += "0" * (6 - len(_lowercase ) % 6)
     else:
          UpperCAmelCase_     :				int  =     B''''''

     # Encode every 6 binary digits to their corresponding Base64 character
     return (
         "".join(
             B64_CHARSET[int(binary_stream[index : index + 6]					,		2 )]
             for index in range(0					,		len(_lowercase )					,		6 ) ).encode()
         + padding
     )







def lowerCamelCase__  (     _lowercase ):

     '''simple docstring'''


     if not isinstance(_lowercase					,		_lowercase ) and not isinstance(_lowercase					,		_lowercase ):
          UpperCAmelCase_     :				Tuple  =     (
              '''argument should be a bytes-like object or ASCII string, '''
              f'''not \'{encoded_data.__class__.__name__}\''''
          )
          raise TypeError(_lowercase )

     # In case encoded_data is a bytes-like object, make sure it contains only
     # ASCII characters so we convert it to a string object
     if isinstance(_lowercase					,		_lowercase ):
          try:
               UpperCAmelCase_     :				Any  =     encoded_data.decode('''utf-8''' )
          except UnicodeDecodeError:
               raise ValueError('''base64 encoded data should only contain ASCII characters''' )

     UpperCAmelCase_     :				str  =     encoded_data.count('''=''' )

     # Check if the encoded string contains non base64 characters
     if padding:
          assert all(
              char in B64_CHARSET for char in encoded_data[:-padding] ), "Invalid base64 character(s) found."
     else:
          assert all(
              char in B64_CHARSET for char in encoded_data ), "Invalid base64 character(s) found."

     # Check the padding
     assert len(_lowercase ) % 4 == 0 and padding < 3, "Incorrect padding"

     if padding:
          # Remove padding if there is one
          UpperCAmelCase_     :				List[Any]  =     encoded_data[:-padding]

          UpperCAmelCase_     :				List[Any]  =     ''''''.join(
              bin(B64_CHARSET.index(_lowercase ) )[2:].zfill(6 ) for char in encoded_data )[: -padding * 2]
     else:
          UpperCAmelCase_     :				Tuple  =     ''''''.join(
              bin(B64_CHARSET.index(_lowercase ) )[2:].zfill(6 ) for char in encoded_data )

     UpperCAmelCase_     :				str  =     [
         int(binary_stream[index : index + 8]					,		2 )
         for index in range(0					,		len(_lowercase )					,		8 )
     ]

     return bytes(_lowercase )


if __name__ == "__main__":
     import doctest

     doctest.testmod()