




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      _a				(						):
					__lowerCAmelCase           =	10
					__lowerCAmelCase           =	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           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Dict				,				SCREAMING_SNAKE_CASE_							:    Optional[int]					):
					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "file.arrow"					)
					dataset.map(cache_file_name=_UpperCAmelCase					)
					return filename


# FILE_CONTENT + files


UpperCamelCase__         =      '''\
    Text data.
    Second line of data.'''







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    Any					):
					__lowerCAmelCase           =	tmp_path_factory.mktemp("data"					) / 'file.txt'
					__lowerCAmelCase           =	FILE_CONTENT
					with open(_UpperCAmelCase				,				"w"					) as f:
										f.write(_UpperCAmelCase					)
					return filename







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    Dict					):
					import bza

					__lowerCAmelCase           =	tmp_path_factory.mktemp("data"					) / 'file.txt.bz2'
					__lowerCAmelCase           =	bytes(_UpperCAmelCase				,				"utf-8"					)
					with bza.open(_UpperCAmelCase				,				"wb"					) as f:
										f.write(_UpperCAmelCase					)
					return path







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    int					):
					import gzip

					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "file.txt.gz"					)
					__lowerCAmelCase           =	bytes(_UpperCAmelCase				,				"utf-8"					)
					with gzip.open(_UpperCAmelCase				,				"wb"					) as f:
										f.write(_UpperCAmelCase					)
					return path







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]					):
					if datasets.config.LZ4_AVAILABLE:
										import lza.frame

										__lowerCAmelCase           =	tmp_path_factory.mktemp("data"					) / 'file.txt.lz4'
										__lowerCAmelCase           =	bytes(_UpperCAmelCase				,				"utf-8"					)
										with lza.frame.open(_UpperCAmelCase				,				"wb"					) as f:
															f.write(_UpperCAmelCase					)
										return path







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    Tuple				,				SCREAMING_SNAKE_CASE_							:    List[Any]					):
					if datasets.config.PY7ZR_AVAILABLE:
										import pyazr

										__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    str				,				SCREAMING_SNAKE_CASE_							:    Dict					):
					import tarfile

					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Any					):
					import lzma

					__lowerCAmelCase           =	tmp_path_factory.mktemp("data"					) / 'file.txt.xz'
					__lowerCAmelCase           =	bytes(_UpperCAmelCase				,				"utf-8"					)
					with lzma.open(_UpperCAmelCase				,				"wb"					) as f:
										f.write(_UpperCAmelCase					)
					return path







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    List[Any]				,				SCREAMING_SNAKE_CASE_							:    Tuple					):
					import zipfile

					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]					):
					if datasets.config.ZSTANDARD_AVAILABLE:
										import zstandard as zstd

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







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[Any]					):
					__lowerCAmelCase           =	tmp_path_factory.mktemp("data"					) / 'file.xml'
					__lowerCAmelCase           =	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__         =      [
    {'''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__         =      [
    {'''col_1''': '''4''', '''col_2''': 4, '''col_3''': 4.0},
    {'''col_1''': '''5''', '''col_2''': 5, '''col_3''': 5.0},
]
UpperCamelCase__         =      {
    '''col_1''': ['''0''', '''1''', '''2''', '''3'''],
    '''col_2''': [0, 1, 2, 3],
    '''col_3''': [0.0, 1.0, 2.0, 3.0],
}

UpperCamelCase__         =      [
    {'''col_3''': 0.0, '''col_1''': '''0''', '''col_2''': 0},
    {'''col_3''': 1.0, '''col_1''': '''1''', '''col_2''': 1},
]

UpperCamelCase__         =      [
    {'''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      _a				(						):
					return DATA_DICT_OF_LISTS







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    List[str]					):
					__lowerCAmelCase           =	datasets.Dataset.from_dict(_UpperCAmelCase					)
					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "dataset.arrow"					)
					dataset.map(cache_file_name=_UpperCAmelCase					)
					return path







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    List[Any]					):
					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "dataset.sqlite"					)
					with contextlib.closing(sqlitea.connect(_UpperCAmelCase					)					) as con:
										__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]					):
					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "dataset.csv"					)
					with open(_UpperCAmelCase				,				"w"				,				newline=""					) as f:
										__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Tuple					):
					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "dataset2.csv"					)
					with open(_UpperCAmelCase				,				"w"				,				newline=""					) as f:
										__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    str				,				SCREAMING_SNAKE_CASE_							:    str					):
					import bza

					__lowerCAmelCase           =	tmp_path_factory.mktemp("data"					) / 'dataset.csv.bz2'
					with open(_UpperCAmelCase				,				"rb"					) as f:
										__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    str				,				SCREAMING_SNAKE_CASE_							:    List[Any]				,				SCREAMING_SNAKE_CASE_							:    Dict					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Tuple				,				SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    Optional[Any]					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    List[str]				,				SCREAMING_SNAKE_CASE_							:    str				,				SCREAMING_SNAKE_CASE_							:    Tuple					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    str					):
					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "dataset.parquet"					)
					__lowerCAmelCase           =	pa.schema(
					    {
					        "col_1": pa.string(),
					        "col_2": pa.intaa(),
					        "col_3": pa.floataa(),
					    }					)
					with open(_UpperCAmelCase				,				"wb"					) as f:
										__lowerCAmelCase           =	pq.ParquetWriter(_UpperCAmelCase				,				schema=_UpperCAmelCase					)
										__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Union[str, Any]					):
					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "dataset.json"					)
					__lowerCAmelCase           =	{'data': DATA}
					with open(_UpperCAmelCase				,				"w"					) as f:
										json.dump(_UpperCAmelCase				,				_UpperCAmelCase					)
					return path







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    Tuple					):
					__lowerCAmelCase           =	str(tmp_path_factory.mktemp("data"					) / "dataset.json"					)
					__lowerCAmelCase           =	{'data': DATA_DICT_OF_LISTS}
					with open(_UpperCAmelCase				,				"w"					) as f:
										json.dump(_UpperCAmelCase				,				_UpperCAmelCase					)
					return path







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    Tuple					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Any					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Any					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    int				,				SCREAMING_SNAKE_CASE_							:    Tuple					):
					import gzip

					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]				,				SCREAMING_SNAKE_CASE_							:    List[Any]					):
					import gzip

					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]				,				SCREAMING_SNAKE_CASE_							:    str				,				SCREAMING_SNAKE_CASE_							:    int					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]				,				SCREAMING_SNAKE_CASE_							:    Tuple				,				SCREAMING_SNAKE_CASE_							:    Optional[Any]				,				SCREAMING_SNAKE_CASE_							:    int					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    List[str]				,				SCREAMING_SNAKE_CASE_							:    Optional[Any]				,				SCREAMING_SNAKE_CASE_							:    Optional[Any]					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    Tuple				,				SCREAMING_SNAKE_CASE_							:    Any					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    List[Any]				,				SCREAMING_SNAKE_CASE_							:    Union[str, Any]				,				SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    Optional[Any]					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Union[str, Any]					):
					__lowerCAmelCase           =	['0', '1', '2', '3']
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    List[str]					):
					__lowerCAmelCase           =	['0', '1', '2', '3']
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[Any]					):
					__lowerCAmelCase           =	['0', '1', '2', '3']
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    List[Any]				,				SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    Optional[int]					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Tuple				,				SCREAMING_SNAKE_CASE_							:    Optional[Any]				,				SCREAMING_SNAKE_CASE_							:    Any					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Dict				,				SCREAMING_SNAKE_CASE_							:    Union[str, Any]				,				SCREAMING_SNAKE_CASE_							:    int					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]					):
					__lowerCAmelCase           =	'\n'.join(["First", "Second\u2029with Unicode new line", "Third"]					)
					__lowerCAmelCase           =	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      _a				(						):
					return os.path.join("tests"				,				"features"				,				"data"				,				"test_image_rgb.jpg"					)







@pytest.fixture(scope="session"					)
def      _a				(						):
					return os.path.join("tests"				,				"features"				,				"data"				,				"test_audio_44100.wav"					)







@pytest.fixture(scope="session"					)
def      _a				(						SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    Optional[Any]					):
					__lowerCAmelCase           =	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      _a				(						SCREAMING_SNAKE_CASE_							:    int					):
					__lowerCAmelCase           =	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 math







def      _a				(						SCREAMING_SNAKE_CASE_							:    int					):

					if 1 < number < 4:
										# 2 and 3 are primes
										return True
					elif number < 2 or number % 2 == 0 or number % 3 == 0:
										# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
										return False

					# All primes number are in format of 6k +/- 1
					for i in range(5				,				int(math.sqrt(SCREAMING_SNAKE_CASE_					) + 1					)				,				6					):
										if number % i == 0 or number % (i + 2) == 0:
															return False
					return True







def      _a				(						SCREAMING_SNAKE_CASE_							:    float = 0.1					):
					__lowerCAmelCase           =	3
					__lowerCAmelCase           =	3

					while primes / (2 * j - 1) >= ratio:
										for i in range(j * j + j + 1				,				(j + 2) * (j + 2)				,				j + 1					):
															primes += is_prime(SCREAMING_SNAKE_CASE_					)
										j += 2
					return j


if __name__ == "__main__":
					import doctest

					doctest.testmod()




