





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        SCREAMING_SNAKE_CASE      (       )			->     List[Any]:
    lowerCamelCase__    :      Union[str, Any]					 =		10
    lowerCamelCase__    :      int					 =		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' ),
        } )
    lowerCamelCase__    :      str					 =		datasets.Dataset.from_dict(
        {
            'tokens': [['foo'] * 5] * n,
            'labels': [[1] * 5] * n,
            'answers': [{'answer_start': [97], 'text': ['1976']}] * 10,
            'id': list(range(_UpperCAmelCase ) ),
        }						,	features=_UpperCAmelCase						,	)
    return dataset


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase )			->     int:
    lowerCamelCase__    :      Dict					 =		str(tmp_path_factory.mktemp('data' ) / 'file.arrow' )
    dataset.map(cache_file_name=_UpperCAmelCase )
    return filename


# FILE_CONTENT + files


_UpperCAmelCase				:       Optional[int]	   =				"""\
    Text data.
    Second line of data."""


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     int:
    lowerCamelCase__    :      Optional[Any]					 =		tmp_path_factory.mktemp('data' ) / 'file.txt'
    lowerCamelCase__    :      Optional[int]					 =		FILE_CONTENT
    with open(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase )
    return filename


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Optional[Any]:
    import bza

    lowerCamelCase__    :      Union[str, Any]					 =		tmp_path_factory.mktemp('data' ) / 'file.txt.bz2'
    lowerCamelCase__    :      Any					 =		bytes(_UpperCAmelCase						,	'utf-8' )
    with bza.open(_UpperCAmelCase						,	'wb' ) as f:
        f.write(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     List[str]:
    import gzip

    lowerCamelCase__    :      Any					 =		str(tmp_path_factory.mktemp('data' ) / 'file.txt.gz' )
    lowerCamelCase__    :      Optional[Any]					 =		bytes(_UpperCAmelCase						,	'utf-8' )
    with gzip.open(_UpperCAmelCase						,	'wb' ) as f:
        f.write(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     int:
    if datasets.config.LZ4_AVAILABLE:
        import lza.frame

        lowerCamelCase__    :      Optional[Any]					 =		tmp_path_factory.mktemp('data' ) / 'file.txt.lz4'
        lowerCamelCase__    :      int					 =		bytes(_UpperCAmelCase						,	'utf-8' )
        with lza.frame.open(_UpperCAmelCase						,	'wb' ) as f:
            f.write(_UpperCAmelCase )
        return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase )			->     List[Any]:
    if datasets.config.PY7ZR_AVAILABLE:
        import pyazr

        lowerCamelCase__    :      List[Any]					 =		tmp_path_factory.mktemp('data' ) / 'file.txt.7z'
        with pyazr.SevenZipFile(_UpperCAmelCase						,	'w' ) as archive:
            archive.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
        return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase )			->     Union[str, Any]:
    import tarfile

    lowerCamelCase__    :      Optional[Any]					 =		tmp_path_factory.mktemp('data' ) / 'file.txt.tar'
    with tarfile.TarFile(_UpperCAmelCase						,	'w' ) as f:
        f.add(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Union[str, Any]:
    import lzma

    lowerCamelCase__    :      int					 =		tmp_path_factory.mktemp('data' ) / 'file.txt.xz'
    lowerCamelCase__    :      Optional[Any]					 =		bytes(_UpperCAmelCase						,	'utf-8' )
    with lzma.open(_UpperCAmelCase						,	'wb' ) as f:
        f.write(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase )			->     Tuple:
    import zipfile

    lowerCamelCase__    :      Optional[int]					 =		tmp_path_factory.mktemp('data' ) / 'file.txt.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     List[Any]:
    if datasets.config.ZSTANDARD_AVAILABLE:
        import zstandard as zstd

        lowerCamelCase__    :      Tuple					 =		tmp_path_factory.mktemp('data' ) / 'file.txt.zst'
        lowerCamelCase__    :      int					 =		bytes(_UpperCAmelCase						,	'utf-8' )
        with zstd.open(_UpperCAmelCase						,	'wb' ) as f:
            f.write(_UpperCAmelCase )
        return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     List[Any]:
    lowerCamelCase__    :      Optional[int]					 =		tmp_path_factory.mktemp('data' ) / 'file.xml'
    lowerCamelCase__    :      Optional[int]					 =		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(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase )
    return filename


_UpperCAmelCase				:       Union[str, Any]	   =				[
    {"""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},
]
_UpperCAmelCase				:       List[Any]	   =				[
    {"""col_1""": """4""", """col_2""": 4, """col_3""": 4.0},
    {"""col_1""": """5""", """col_2""": 5, """col_3""": 5.0},
]
_UpperCAmelCase				:       Optional[int]	   =				{
    """col_1""": ["""0""", """1""", """2""", """3"""],
    """col_2""": [0, 1, 2, 3],
    """col_3""": [0.0, 1.0, 2.0, 3.0],
}

_UpperCAmelCase				:       Any	   =				[
    {"""col_3""": 0.0, """col_1""": """0""", """col_2""": 0},
    {"""col_3""": 1.0, """col_1""": """1""", """col_2""": 1},
]

_UpperCAmelCase				:       int	   =				[
    {"""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        SCREAMING_SNAKE_CASE      (       )			->     Optional[int]:
    return DATA_DICT_OF_LISTS


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Optional[int]:
    lowerCamelCase__    :      int					 =		datasets.Dataset.from_dict(_UpperCAmelCase )
    lowerCamelCase__    :      str					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.arrow' )
    dataset.map(cache_file_name=_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     List[Any]:
    lowerCamelCase__    :      Tuple					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.sqlite' )
    with contextlib.closing(sqlitea.connect(_UpperCAmelCase ) ) as con:
        lowerCamelCase__    :      List[str]					 =		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        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     str:
    lowerCamelCase__    :      Tuple					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.csv' )
    with open(_UpperCAmelCase						,	'w'						,	newline='' ) as f:
        lowerCamelCase__    :      str					 =		csv.DictWriter(_UpperCAmelCase						,	fieldnames=['col_1', 'col_2', 'col_3'] )
        writer.writeheader()
        for item in DATA:
            writer.writerow(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     str:
    lowerCamelCase__    :      Optional[int]					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset2.csv' )
    with open(_UpperCAmelCase						,	'w'						,	newline='' ) as f:
        lowerCamelCase__    :      str					 =		csv.DictWriter(_UpperCAmelCase						,	fieldnames=['col_1', 'col_2', 'col_3'] )
        writer.writeheader()
        for item in DATA:
            writer.writerow(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase )			->     str:
    import bza

    lowerCamelCase__    :      Dict					 =		tmp_path_factory.mktemp('data' ) / 'dataset.csv.bz2'
    with open(_UpperCAmelCase						,	'rb' ) as f:
        lowerCamelCase__    :      List[Any]					 =		f.read()
    # data = bytes(FILE_CONTENT, "utf-8")
    with bza.open(_UpperCAmelCase						,	'wb' ) as f:
        f.write(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     Any:
    lowerCamelCase__    :      int					 =		tmp_path_factory.mktemp('data' ) / 'dataset.csv.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     Dict:
    lowerCamelCase__    :      List[str]					 =		tmp_path_factory.mktemp('data' ) / 'dataset.csv.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(csv_path.replace('.csv'						,	'.CSV' ) ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(csva_path.replace('.csv'						,	'.CSV' ) ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     List[str]:
    lowerCamelCase__    :      str					 =		tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.csv.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.join('main_dir'						,	os.path.basename(_UpperCAmelCase ) ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.join('main_dir'						,	os.path.basename(_UpperCAmelCase ) ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     List[Any]:
    lowerCamelCase__    :      Optional[int]					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.parquet' )
    lowerCamelCase__    :      List[str]					 =		pa.schema(
        {
            'col_1': pa.string(),
            'col_2': pa.intaa(),
            'col_3': pa.floataa(),
        } )
    with open(_UpperCAmelCase						,	'wb' ) as f:
        lowerCamelCase__    :      Union[str, Any]					 =		pq.ParquetWriter(_UpperCAmelCase						,	schema=_UpperCAmelCase )
        lowerCamelCase__    :      Optional[int]					 =		pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(_UpperCAmelCase ) )] for k in DATA[0]}						,	schema=_UpperCAmelCase )
        writer.write_table(_UpperCAmelCase )
        writer.close()
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Optional[int]:
    lowerCamelCase__    :      List[Any]					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.json' )
    lowerCamelCase__    :      Tuple					 =		{'data': DATA}
    with open(_UpperCAmelCase						,	'w' ) as f:
        json.dump(_UpperCAmelCase						,	_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     List[str]:
    lowerCamelCase__    :      Dict					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.json' )
    lowerCamelCase__    :      int					 =		{'data': DATA_DICT_OF_LISTS}
    with open(_UpperCAmelCase						,	'w' ) as f:
        json.dump(_UpperCAmelCase						,	_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Union[str, Any]:
    lowerCamelCase__    :      Union[str, Any]					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.jsonl' )
    with open(_UpperCAmelCase						,	'w' ) as f:
        for item in DATA:
            f.write(json.dumps(_UpperCAmelCase ) + '\n' )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Optional[Any]:
    lowerCamelCase__    :      str					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset2.jsonl' )
    with open(_UpperCAmelCase						,	'w' ) as f:
        for item in DATA:
            f.write(json.dumps(_UpperCAmelCase ) + '\n' )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     str:
    lowerCamelCase__    :      str					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset_312.jsonl' )
    with open(_UpperCAmelCase						,	'w' ) as f:
        for item in DATA_312:
            f.write(json.dumps(_UpperCAmelCase ) + '\n' )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Optional[int]:
    lowerCamelCase__    :      str					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset-str.jsonl' )
    with open(_UpperCAmelCase						,	'w' ) as f:
        for item in DATA_STR:
            f.write(json.dumps(_UpperCAmelCase ) + '\n' )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase )			->     Union[str, Any]:
    import gzip

    lowerCamelCase__    :      Union[str, Any]					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.txt.gz' )
    with open(_UpperCAmelCase						,	'rb' ) as orig_file:
        with gzip.open(_UpperCAmelCase						,	'wb' ) as zipped_file:
            zipped_file.writelines(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase )			->     Tuple:
    import gzip

    lowerCamelCase__    :      List[Any]					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.gz' )
    with open(_UpperCAmelCase						,	'rb' ) as orig_file:
        with gzip.open(_UpperCAmelCase						,	'wb' ) as zipped_file:
            zipped_file.writelines(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     str:
    lowerCamelCase__    :      Optional[int]					 =		tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     Any:
    lowerCamelCase__    :      List[str]					 =		tmp_path_factory.mktemp('data' ) / 'dataset_nested.jsonl.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.join('nested'						,	os.path.basename(_UpperCAmelCase ) ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     Union[str, Any]:
    lowerCamelCase__    :      Optional[Any]					 =		tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.jsonl.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.join('main_dir'						,	os.path.basename(_UpperCAmelCase ) ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.join('main_dir'						,	os.path.basename(_UpperCAmelCase ) ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     Tuple:
    lowerCamelCase__    :      Optional[int]					 =		tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.tar'
    with tarfile.TarFile(_UpperCAmelCase						,	'w' ) as f:
        f.add(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
        f.add(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     Optional[Any]:
    lowerCamelCase__    :      Union[str, Any]					 =		tmp_path_factory.mktemp('data' ) / 'dataset_nested.jsonl.tar'
    with tarfile.TarFile(_UpperCAmelCase						,	'w' ) as f:
        f.add(_UpperCAmelCase						,	arcname=os.path.join('nested'						,	os.path.basename(_UpperCAmelCase ) ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     List[str]:
    lowerCamelCase__    :      int					 =		['0', '1', '2', '3']
    lowerCamelCase__    :      Tuple					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset.txt' )
    with open(_UpperCAmelCase						,	'w' ) as f:
        for item in data:
            f.write(item + '\n' )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     int:
    lowerCamelCase__    :      Dict					 =		['0', '1', '2', '3']
    lowerCamelCase__    :      Union[str, Any]					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset2.txt' )
    with open(_UpperCAmelCase						,	'w' ) as f:
        for item in data:
            f.write(item + '\n' )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Tuple:
    lowerCamelCase__    :      List[Any]					 =		['0', '1', '2', '3']
    lowerCamelCase__    :      str					 =		tmp_path_factory.mktemp('data' ) / 'dataset.abc'
    with open(_UpperCAmelCase						,	'w' ) as f:
        for item in data:
            f.write(item + '\n' )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     Union[str, Any]:
    lowerCamelCase__    :      Dict					 =		tmp_path_factory.mktemp('data' ) / 'dataset.text.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     List[str]:
    lowerCamelCase__    :      Optional[int]					 =		tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.text.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.join('main_dir'						,	os.path.basename(_UpperCAmelCase ) ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.join('main_dir'						,	os.path.basename(_UpperCAmelCase ) ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     Tuple:
    lowerCamelCase__    :      List[Any]					 =		tmp_path_factory.mktemp('data' ) / 'dataset.ext.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.basename('unsupported.ext' ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.basename('unsupported_2.ext' ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Optional[int]:
    lowerCamelCase__    :      Optional[int]					 =		'\n'.join(['First', 'Second\u2029with Unicode new line', 'Third'] )
    lowerCamelCase__    :      Optional[Any]					 =		str(tmp_path_factory.mktemp('data' ) / 'dataset_with_unicode_new_lines.txt' )
    with open(_UpperCAmelCase						,	'w'						,	encoding='utf-8' ) as f:
        f.write(_UpperCAmelCase )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       )			->     Tuple:
    return os.path.join('tests'						,	'features'						,	'data'						,	'test_image_rgb.jpg' )


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       )			->     Dict:
    return os.path.join('tests'						,	'features'						,	'data'						,	'test_audio_44100.wav' )


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase )			->     Optional[int]:
    lowerCamelCase__    :      int					 =		tmp_path_factory.mktemp('data' ) / 'dataset.img.zip'
    with zipfile.ZipFile(_UpperCAmelCase						,	'w' ) as f:
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ) )
        f.write(_UpperCAmelCase						,	arcname=os.path.basename(_UpperCAmelCase ).replace('.jpg'						,	'2.jpg' ) )
    return path


@pytest.fixture(scope='session' )
def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     Any:
    lowerCamelCase__    :      List[Any]					 =		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












def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     set:
    lowerCamelCase__    :      Optional[Any]					 =		set()
    # edges = list of graph's edges
    lowerCamelCase__    :      List[str]					 =		get_edges(_UpperCAmelCase )

    # While there are still elements in edges list, take an arbitrary edge
    # (from_node, to_node) and add his extremity to chosen_vertices and then
    # remove all arcs adjacent to the from_node and to_node
    while edges:
        lowerCamelCase__ ,							lowerCamelCase__    :      str					 =		edges.pop()
        chosen_vertices.add(_UpperCAmelCase )
        chosen_vertices.add(_UpperCAmelCase )
        for edge in edges.copy():
            if from_node in edge or to_node in edge:
                edges.discard(_UpperCAmelCase )
    return chosen_vertices


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     set:
    lowerCamelCase__    :      Union[str, Any]					 =		set()
    for from_node, to_nodes in graph.items():
        for to_node in to_nodes:
            edges.add((from_node, to_node) )
    return edges


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    # graph = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]}
    # print(f"Matching vertex cover:\n{matching_min_vertex_cover(graph)}")





