






import contextlib
import csv
import json
import os
import sqlitea
import tarfile
import textwrap
import zipfile

import pyarrow as pa
import pyarrow.parquet as pq
import pytest

import datasets
import datasets.config
@pytest.fixture(scope='session')
def     _snake_case    ():
   UpperCamelCase_									=     10
   UpperCamelCase_									=     datasets.Features(
       {
           'tokens': datasets.Sequence(datasets.Value('string')),
           'labels': datasets.Sequence(datasets.ClassLabel(names=['negative', 'positive'])),
           'answers': datasets.Sequence(
               {
                   'text': datasets.Value('string'),
                   'answer_start': datasets.Value('int32'),
               }),
           'id': datasets.Value('int64'),
       })
   UpperCamelCase_									=     datasets.Dataset.from_dict(
       {
           'tokens': [['foo'] * 5] * n,
           'labels': [[1] * 5] * n,
           'answers': [{'answer_start': [97], 'text': ['1976']}] * 10,
           'id': list(range(__lowercase)),
       }    ,      features=__lowercase    ,      )
   return dataset
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'file.arrow')
   dataset.map(cache_file_name=__lowercase)
   return filename


# FILE_CONTENT + files


snake_case__      :	List[Any]       	=      """\
    Text data.
    Second line of data."""
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.txt'
   UpperCamelCase_									=     FILE_CONTENT
   with open(__lowercase    ,      'w') as f:
      f.write(__lowercase)
   return filename
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   import bza

   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.txt.bz2'
   UpperCamelCase_									=     bytes(__lowercase    ,      'utf-8')
   with bza.open(__lowercase    ,      'wb') as f:
      f.write(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   import gzip

   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'file.txt.gz')
   UpperCamelCase_									=     bytes(__lowercase    ,      'utf-8')
   with gzip.open(__lowercase    ,      'wb') as f:
      f.write(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   if datasets.config.LZ4_AVAILABLE:
      import lza.frame

      UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.txt.lz4'
      UpperCamelCase_									=     bytes(__lowercase    ,      'utf-8')
      with lza.frame.open(__lowercase    ,      'wb') as f:
         f.write(__lowercase)
      return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase):
   if datasets.config.PY7ZR_AVAILABLE:
      import pyazr

      UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.txt.7z'
      with pyazr.SevenZipFile(__lowercase    ,      'w') as archive:
         archive.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
      return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase):
   import tarfile

   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.txt.tar'
   with tarfile.TarFile(__lowercase    ,      'w') as f:
      f.add(__lowercase    ,      arcname=os.path.basename(__lowercase))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   import lzma

   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.txt.xz'
   UpperCamelCase_									=     bytes(__lowercase    ,      'utf-8')
   with lzma.open(__lowercase    ,      'wb') as f:
      f.write(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase):
   import zipfile

   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.txt.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   if datasets.config.ZSTANDARD_AVAILABLE:
      import zstandard as zstd

      UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.txt.zst'
      UpperCamelCase_									=     bytes(__lowercase    ,      'utf-8')
      with zstd.open(__lowercase    ,      'wb') as f:
         f.write(__lowercase)
      return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'file.xml'
   UpperCamelCase_									=     textwrap.dedent(
       '\\n    <?xml version="1.0" encoding="UTF-8" ?>\n    <tmx version="1.4">\n      <header segtype="sentence" srclang="ca" />\n      <body>\n        <tu>\n          <tuv xml:lang="ca"><seg>Contingut 1</seg></tuv>\n          <tuv xml:lang="en"><seg>Content 1</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang="ca"><seg>Contingut 2</seg></tuv>\n          <tuv xml:lang="en"><seg>Content 2</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang="ca"><seg>Contingut 3</seg></tuv>\n          <tuv xml:lang="en"><seg>Content 3</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang="ca"><seg>Contingut 4</seg></tuv>\n          <tuv xml:lang="en"><seg>Content 4</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang="ca"><seg>Contingut 5</seg></tuv>\n          <tuv xml:lang="en"><seg>Content 5</seg></tuv>\n        </tu>\n      </body>\n    </tmx>')
   with open(__lowercase    ,      'w') as f:
      f.write(__lowercase)
   return filename


snake_case__      :	Dict       	=      [
    {"""col_1""": """0""", """col_2""": 0, """col_3""": 0.0},
    {"""col_1""": """1""", """col_2""": 1, """col_3""": 1.0},
    {"""col_1""": """2""", """col_2""": 2, """col_3""": 2.0},
    {"""col_1""": """3""", """col_2""": 3, """col_3""": 3.0},
]
snake_case__      :	List[Any]       	=      [
    {"""col_1""": """4""", """col_2""": 4, """col_3""": 4.0},
    {"""col_1""": """5""", """col_2""": 5, """col_3""": 5.0},
]
snake_case__      :	Optional[int]       	=      {
    """col_1""": ["""0""", """1""", """2""", """3"""],
    """col_2""": [0, 1, 2, 3],
    """col_3""": [0.0, 1.0, 2.0, 3.0],
}

snake_case__      :	Optional[int]       	=      [
    {"""col_3""": 0.0, """col_1""": """0""", """col_2""": 0},
    {"""col_3""": 1.0, """col_1""": """1""", """col_2""": 1},
]

snake_case__      :	Tuple       	=      [
    {"""col_1""": """s0""", """col_2""": 0, """col_3""": 0.0},
    {"""col_1""": """s1""", """col_2""": 1, """col_3""": 1.0},
    {"""col_1""": """s2""", """col_2""": 2, """col_3""": 2.0},
    {"""col_1""": """s3""", """col_2""": 3, """col_3""": 3.0},
]
@pytest.fixture(scope='session')
def     _snake_case    ():
   return DATA_DICT_OF_LISTS
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     datasets.Dataset.from_dict(__lowercase)
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.arrow')
   dataset.map(cache_file_name=__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.sqlite')
   with contextlib.closing(sqlitea.connect(__lowercase)) as con:
      UpperCamelCase_									=     con.cursor()
      cur.execute('CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)')
      for item in DATA:
         cur.execute('INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)'    ,      tuple(item.values()))
      con.commit()
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.csv')
   with open(__lowercase    ,      'w'    ,      newline='') as f:
      UpperCamelCase_									=     csv.DictWriter(__lowercase    ,      fieldnames=['col_1', 'col_2', 'col_3'])
      writer.writeheader()
      for item in DATA:
         writer.writerow(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset2.csv')
   with open(__lowercase    ,      'w'    ,      newline='') as f:
      UpperCamelCase_									=     csv.DictWriter(__lowercase    ,      fieldnames=['col_1', 'col_2', 'col_3'])
      writer.writeheader()
      for item in DATA:
         writer.writerow(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase):
   import bza

   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.csv.bz2'
   with open(__lowercase    ,      'rb') as f:
      UpperCamelCase_									=     f.read()
   # data = bytes(FILE_CONTENT, "utf-8")
   with bza.open(__lowercase    ,      'wb') as f:
      f.write(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.csv.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.csv.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.basename(csv_path.replace('.csv'    ,      '.CSV')))
      f.write(__lowercase    ,      arcname=os.path.basename(csva_path.replace('.csv'    ,      '.CSV')))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset_with_dir.csv.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.join('main_dir'    ,      os.path.basename(__lowercase)))
      f.write(__lowercase    ,      arcname=os.path.join('main_dir'    ,      os.path.basename(__lowercase)))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.parquet')
   UpperCamelCase_									=     pa.schema(
       {
           'col_1': pa.string(),
           'col_2': pa.intaa(),
           'col_3': pa.floataa(),
       })
   with open(__lowercase    ,      'wb') as f:
      UpperCamelCase_									=     pq.ParquetWriter(__lowercase    ,      schema=__lowercase)
      UpperCamelCase_									=     pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(__lowercase))] for k in DATA[0]}    ,      schema=__lowercase)
      writer.write_table(__lowercase)
      writer.close()
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.json')
   UpperCamelCase_									=     {'data': DATA}
   with open(__lowercase    ,      'w') as f:
      json.dump(__lowercase    ,      __lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.json')
   UpperCamelCase_									=     {'data': DATA_DICT_OF_LISTS}
   with open(__lowercase    ,      'w') as f:
      json.dump(__lowercase    ,      __lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.jsonl')
   with open(__lowercase    ,      'w') as f:
      for item in DATA:
         f.write(json.dumps(__lowercase) + '\n')
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset2.jsonl')
   with open(__lowercase    ,      'w') as f:
      for item in DATA:
         f.write(json.dumps(__lowercase) + '\n')
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset_312.jsonl')
   with open(__lowercase    ,      'w') as f:
      for item in DATA_312:
         f.write(json.dumps(__lowercase) + '\n')
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset-str.jsonl')
   with open(__lowercase    ,      'w') as f:
      for item in DATA_STR:
         f.write(json.dumps(__lowercase) + '\n')
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase):
   import gzip

   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.txt.gz')
   with open(__lowercase    ,      'rb') as orig_file:
      with gzip.open(__lowercase    ,      'wb') as zipped_file:
         zipped_file.writelines(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase):
   import gzip

   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.jsonl.gz')
   with open(__lowercase    ,      'rb') as orig_file:
      with gzip.open(__lowercase    ,      'wb') as zipped_file:
         zipped_file.writelines(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.jsonl.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset_nested.jsonl.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.join('nested'    ,      os.path.basename(__lowercase)))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset_with_dir.jsonl.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.join('main_dir'    ,      os.path.basename(__lowercase)))
      f.write(__lowercase    ,      arcname=os.path.join('main_dir'    ,      os.path.basename(__lowercase)))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.jsonl.tar'
   with tarfile.TarFile(__lowercase    ,      'w') as f:
      f.add(__lowercase    ,      arcname=os.path.basename(__lowercase))
      f.add(__lowercase    ,      arcname=os.path.basename(__lowercase))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset_nested.jsonl.tar'
   with tarfile.TarFile(__lowercase    ,      'w') as f:
      f.add(__lowercase    ,      arcname=os.path.join('nested'    ,      os.path.basename(__lowercase)))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     ['0', '1', '2', '3']
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset.txt')
   with open(__lowercase    ,      'w') as f:
      for item in data:
         f.write(item + '\n')
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     ['0', '1', '2', '3']
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset2.txt')
   with open(__lowercase    ,      'w') as f:
      for item in data:
         f.write(item + '\n')
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     ['0', '1', '2', '3']
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.abc'
   with open(__lowercase    ,      'w') as f:
      for item in data:
         f.write(item + '\n')
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.text.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset_with_dir.text.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.join('main_dir'    ,      os.path.basename(__lowercase)))
      f.write(__lowercase    ,      arcname=os.path.join('main_dir'    ,      os.path.basename(__lowercase)))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.ext.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.basename('unsupported.ext'))
      f.write(__lowercase    ,      arcname=os.path.basename('unsupported_2.ext'))
   return path
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     '\n'.join(['First', 'Second\u2029with Unicode new line', 'Third'])
   UpperCamelCase_									=     str(tmp_path_factory.mktemp('data') / 'dataset_with_unicode_new_lines.txt')
   with open(__lowercase    ,      'w'    ,      encoding='utf-8') as f:
      f.write(__lowercase)
   return path
@pytest.fixture(scope='session')
def     _snake_case    ():
   return os.path.join('tests'    ,      'features'    ,      'data'    ,      'test_image_rgb.jpg')
@pytest.fixture(scope='session')
def     _snake_case    ():
   return os.path.join('tests'    ,      'features'    ,      'data'    ,      'test_audio_44100.wav')
@pytest.fixture(scope='session')
def     _snake_case    (__lowercase    ,      __lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data') / 'dataset.img.zip'
   with zipfile.ZipFile(__lowercase    ,      'w') as f:
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase))
      f.write(__lowercase    ,      arcname=os.path.basename(__lowercase).replace('.jpg'    ,      '2.jpg'))
   return path

@pytest.fixture(scope='session')
def     _snake_case    (__lowercase):
   UpperCamelCase_									=     tmp_path_factory.mktemp('data_dir')

   (data_dir / "subdir").mkdir()
   with open(data_dir / 'subdir' / 'train.txt'    ,      'w') as f:
      f.write('foo\n' * 10)
   with open(data_dir / 'subdir' / 'test.txt'    ,      'w') as f:
      f.write('bar\n' * 10)
   # hidden file
   with open(data_dir / 'subdir' / '.test.txt'    ,      'w') as f:
      f.write('bar\n' * 10)

   # hidden directory
   (data_dir / ".subdir").mkdir()
   with open(data_dir / '.subdir' / 'train.txt'    ,      'w') as f:
      f.write('foo\n' * 10)
   with open(data_dir / '.subdir' / 'test.txt'    ,      'w') as f:
      f.write('bar\n' * 10)

   return data_dir













import os

import pytest

from datasets import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
)


snake_case__      :	Optional[int]       	=      pytest.mark.integration






@pytest.mark.parametrize('path'    ,      ['paws', 'csv'])
def     _snake_case    (__lowercase    ,      __lowercase):
   inspect_dataset(__lowercase    ,      __lowercase)
   UpperCamelCase_									=     path + '.py'
   assert script_name in os.listdir(__lowercase)
   assert "__pycache__" not in os.listdir(__lowercase)






@pytest.mark.filterwarnings('ignore:inspect_metric is deprecated:FutureWarning')
@pytest.mark.filterwarnings('ignore:metric_module_factory is deprecated:FutureWarning')
@pytest.mark.parametrize('path'    ,      ['accuracy'])
def     _snake_case    (__lowercase    ,      __lowercase):
   inspect_metric(__lowercase    ,      __lowercase)
   UpperCamelCase_									=     path + '.py'
   assert script_name in os.listdir(__lowercase)
   assert "__pycache__" not in os.listdir(__lowercase)






@pytest.mark.parametrize(
    'path, config_name, expected_splits'    ,      [
        ('squad', 'plain_text', ['train', 'validation']),
        ('dalle-mini/wit', 'dalle-mini--wit', ['train']),
        ('paws', 'labeled_final', ['train', 'test', 'validation']),
    ]    ,      )
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     get_dataset_config_info(__lowercase    ,      config_name=__lowercase)
   assert info.config_name == config_name
   assert list(info.splits.keys()) == expected_splits






@pytest.mark.parametrize(
    'path, config_name, expected_exception'    ,      [
        ('paws', None, ValueError),
    ]    ,      )
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   with pytest.raises(__lowercase):
      get_dataset_config_info(__lowercase    ,      config_name=__lowercase)






@pytest.mark.parametrize(
    'path, expected'    ,      [
        ('squad', 'plain_text'),
        ('acronym_identification', 'default'),
        ('lhoestq/squad', 'plain_text'),
        ('lhoestq/test', 'default'),
        ('lhoestq/demo1', 'lhoestq--demo1'),
        ('dalle-mini/wit', 'dalle-mini--wit'),
    ]    ,      )
def     _snake_case    (__lowercase    ,      __lowercase):
   UpperCamelCase_									=     get_dataset_config_names(__lowercase)
   assert expected in config_names






@pytest.mark.parametrize(
    'path, expected_configs, expected_splits_in_first_config'    ,      [
        ('squad', ['plain_text'], ['train', 'validation']),
        ('dalle-mini/wit', ['dalle-mini--wit'], ['train']),
        ('paws', ['labeled_final', 'labeled_swap', 'unlabeled_final'], ['train', 'test', 'validation']),
    ]    ,      )
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     get_dataset_infos(__lowercase)
   assert list(infos.keys()) == expected_configs
   UpperCamelCase_									=     expected_configs[0]
   assert expected_config in infos
   UpperCamelCase_									=     infos[expected_config]
   assert info.config_name == expected_config
   assert list(info.splits.keys()) == expected_splits_in_first_config






@pytest.mark.parametrize(
    'path, expected_config, expected_splits'    ,      [
        ('squad', 'plain_text', ['train', 'validation']),
        ('dalle-mini/wit', 'dalle-mini--wit', ['train']),
        ('paws', 'labeled_final', ['train', 'test', 'validation']),
    ]    ,      )
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   UpperCamelCase_									=     get_dataset_infos(__lowercase)
   assert expected_config in infos
   UpperCamelCase_									=     infos[expected_config]
   assert info.config_name == expected_config
   assert list(info.splits.keys()) == expected_splits






@pytest.mark.parametrize(
    'path, config_name, expected_exception'    ,      [
        ('paws', None, ValueError),
    ]    ,      )
def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   with pytest.raises(__lowercase):
      get_dataset_split_names(__lowercase    ,      config_name=__lowercase)





