


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     lowerCAmelCase_					( ):
							__snake_case		:      str										=       1_0
							__snake_case		:      Optional[Any]										=       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"     ),
							    }     )
							__snake_case		:      Union[str, Any]										=       datasets.Dataset.from_dict(
							    {
							        "tokens": [["foo"] * 5] * n,
							        "labels": [[1] * 5] * n,
							        "answers": [{"answer_start": [9_7], "text": ["1976"]}] * 1_0,
							        "id": list(range(__lowerCAmelCase     )     ),
							    }							,     features=__lowerCAmelCase							,     )
							return dataset







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Optional[Any]										=       str(tmp_path_factory.mktemp("data"     ) / "file.arrow"     )
							dataset.map(cache_file_name=__lowerCAmelCase     )
							return filename


# FILE_CONTENT + files


_snake_case					:		int   =    "\\n    Text data.\n    Second line of data."







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      List[str]										=       tmp_path_factory.mktemp("data"     ) / '''file.txt'''
							__snake_case		:      Tuple										=       FILE_CONTENT
							with open(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase     )
							return filename







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							import bza

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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							import gzip

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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):

							if datasets.config.LZ4_AVAILABLE:
														import lza.frame

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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):

							if datasets.config.PY7ZR_AVAILABLE:
														import pyazr

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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							import tarfile

							__snake_case		:      Tuple										=       tmp_path_factory.mktemp("data"     ) / '''file.txt.tar'''
							with tarfile.TarFile(__lowerCAmelCase							,     "w"     ) as f:
														f.add(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							import lzma

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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							import zipfile

							__snake_case		:      str										=       tmp_path_factory.mktemp("data"     ) / '''file.txt.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):

							if datasets.config.ZSTANDARD_AVAILABLE:
														import zstandard as zstd

														__snake_case		:      Union[str, Any]										=       tmp_path_factory.mktemp("data"     ) / '''file.txt.zst'''
														__snake_case		:      List[Any]										=       bytes(__lowerCAmelCase							,     "utf-8"     )
														with zstd.open(__lowerCAmelCase							,     "wb"     ) as f:
																					f.write(__lowerCAmelCase     )
														return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      List[str]										=       tmp_path_factory.mktemp("data"     ) / '''file.xml'''
							__snake_case		:      Dict										=       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(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase     )
							return filename


_snake_case					:		Optional[int]   =    [
    {"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[str]   =    [
    {"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					:		Dict   =    [
    {"col_3": 0.0, "col_1": "0", "col_2": 0},
    {"col_3": 1.0, "col_1": "1", "col_2": 1},
]

_snake_case					:		str   =    [
    {"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     lowerCAmelCase_					( ):
							return DATA_DICT_OF_LISTS







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      List[Any]										=       datasets.Dataset.from_dict(__lowerCAmelCase     )
							__snake_case		:      Tuple										=       str(tmp_path_factory.mktemp("data"     ) / "dataset.arrow"     )
							dataset.map(cache_file_name=__lowerCAmelCase     )
							return path







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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Dict										=       str(tmp_path_factory.mktemp("data"     ) / "dataset2.csv"     )
							with open(__lowerCAmelCase							,     "w"							,     newline=""     ) as f:
														__snake_case		:      Tuple										=       csv.DictWriter(__lowerCAmelCase							,     fieldnames=["col_1", "col_2", "col_3"]     )
														writer.writeheader()
														for item in DATA:
																					writer.writerow(__lowerCAmelCase     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							import bza

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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      List[str]										=       tmp_path_factory.mktemp("data"     ) / '''dataset.csv.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      str										=       tmp_path_factory.mktemp("data"     ) / '''dataset.csv.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(csv_path.replace(".csv"							,     ".CSV"     )     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(csva_path.replace(".csv"							,     ".CSV"     )     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      List[Any]										=       tmp_path_factory.mktemp("data"     ) / '''dataset_with_dir.csv.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.join("main_dir"							,     os.path.basename(__lowerCAmelCase     )     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.join("main_dir"							,     os.path.basename(__lowerCAmelCase     )     )     )
							return path







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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Tuple										=       str(tmp_path_factory.mktemp("data"     ) / "dataset.json"     )
							__snake_case		:      Any										=       {'''data''': DATA}
							with open(__lowerCAmelCase							,     "w"     ) as f:
														json.dump(__lowerCAmelCase							,     __lowerCAmelCase     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Optional[int]										=       str(tmp_path_factory.mktemp("data"     ) / "dataset.json"     )
							__snake_case		:      Tuple										=       {'''data''': DATA_DICT_OF_LISTS}
							with open(__lowerCAmelCase							,     "w"     ) as f:
														json.dump(__lowerCAmelCase							,     __lowerCAmelCase     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Dict										=       str(tmp_path_factory.mktemp("data"     ) / "dataset.jsonl"     )
							with open(__lowerCAmelCase							,     "w"     ) as f:
														for item in DATA:
																					f.write(json.dumps(__lowerCAmelCase     ) + "\n"     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      List[str]										=       str(tmp_path_factory.mktemp("data"     ) / "dataset2.jsonl"     )
							with open(__lowerCAmelCase							,     "w"     ) as f:
														for item in DATA:
																					f.write(json.dumps(__lowerCAmelCase     ) + "\n"     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      str										=       str(tmp_path_factory.mktemp("data"     ) / "dataset_312.jsonl"     )
							with open(__lowerCAmelCase							,     "w"     ) as f:
														for item in DATA_312:
																					f.write(json.dumps(__lowerCAmelCase     ) + "\n"     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      str										=       str(tmp_path_factory.mktemp("data"     ) / "dataset-str.jsonl"     )
							with open(__lowerCAmelCase							,     "w"     ) as f:
														for item in DATA_STR:
																					f.write(json.dumps(__lowerCAmelCase     ) + "\n"     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							import gzip

							__snake_case		:      Any										=       str(tmp_path_factory.mktemp("data"     ) / "dataset.txt.gz"     )
							with open(__lowerCAmelCase							,     "rb"     ) as orig_file:
														with gzip.open(__lowerCAmelCase							,     "wb"     ) as zipped_file:
																					zipped_file.writelines(__lowerCAmelCase     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							import gzip

							__snake_case		:      Optional[int]										=       str(tmp_path_factory.mktemp("data"     ) / "dataset.jsonl.gz"     )
							with open(__lowerCAmelCase							,     "rb"     ) as orig_file:
														with gzip.open(__lowerCAmelCase							,     "wb"     ) as zipped_file:
																					zipped_file.writelines(__lowerCAmelCase     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Tuple										=       tmp_path_factory.mktemp("data"     ) / '''dataset.jsonl.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Tuple										=       tmp_path_factory.mktemp("data"     ) / '''dataset_nested.jsonl.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.join("nested"							,     os.path.basename(__lowerCAmelCase     )     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      List[Any]										=       tmp_path_factory.mktemp("data"     ) / '''dataset_with_dir.jsonl.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.join("main_dir"							,     os.path.basename(__lowerCAmelCase     )     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.join("main_dir"							,     os.path.basename(__lowerCAmelCase     )     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      str										=       tmp_path_factory.mktemp("data"     ) / '''dataset.jsonl.tar'''
							with tarfile.TarFile(__lowerCAmelCase							,     "w"     ) as f:
														f.add(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
														f.add(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Optional[int]										=       tmp_path_factory.mktemp("data"     ) / '''dataset_nested.jsonl.tar'''
							with tarfile.TarFile(__lowerCAmelCase							,     "w"     ) as f:
														f.add(__lowerCAmelCase							,     arcname=os.path.join("nested"							,     os.path.basename(__lowerCAmelCase     )     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Union[str, Any]										=       ['''0''', '''1''', '''2''', '''3''']
							__snake_case		:      int										=       str(tmp_path_factory.mktemp("data"     ) / "dataset.txt"     )
							with open(__lowerCAmelCase							,     "w"     ) as f:
														for item in data:
																					f.write(item + "\n"     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Union[str, Any]										=       ['''0''', '''1''', '''2''', '''3''']
							__snake_case		:      Union[str, Any]										=       str(tmp_path_factory.mktemp("data"     ) / "dataset2.txt"     )
							with open(__lowerCAmelCase							,     "w"     ) as f:
														for item in data:
																					f.write(item + "\n"     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Any										=       ['''0''', '''1''', '''2''', '''3''']
							__snake_case		:      Dict										=       tmp_path_factory.mktemp("data"     ) / '''dataset.abc'''
							with open(__lowerCAmelCase							,     "w"     ) as f:
														for item in data:
																					f.write(item + "\n"     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Tuple										=       tmp_path_factory.mktemp("data"     ) / '''dataset.text.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Union[str, Any]										=       tmp_path_factory.mktemp("data"     ) / '''dataset_with_dir.text.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.join("main_dir"							,     os.path.basename(__lowerCAmelCase     )     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.join("main_dir"							,     os.path.basename(__lowerCAmelCase     )     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Tuple										=       tmp_path_factory.mktemp("data"     ) / '''dataset.ext.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.basename("unsupported.ext"     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.basename("unsupported_2.ext"     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Dict										=       '''\n'''.join(["First", "Second\u2029with Unicode new line", "Third"]     )
							__snake_case		:      List[str]										=       str(tmp_path_factory.mktemp("data"     ) / "dataset_with_unicode_new_lines.txt"     )
							with open(__lowerCAmelCase							,     "w"							,     encoding="utf-8"     ) as f:
														f.write(__lowerCAmelCase     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( ):
							return os.path.join("tests"							,     "features"							,     "data"							,     "test_image_rgb.jpg"     )







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







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Union[str, Any]										=       tmp_path_factory.mktemp("data"     ) / '''dataset.img.zip'''
							with zipfile.ZipFile(__lowerCAmelCase							,     "w"     ) as f:
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     )     )
														f.write(__lowerCAmelCase							,     arcname=os.path.basename(__lowerCAmelCase     ).replace(".jpg"							,     "2.jpg"     )     )
							return path







@pytest.fixture(scope="session"     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Union[str, 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" * 1_0     )
							with open(data_dir / "subdir" / "test.txt"							,     "w"     ) as f:
														f.write("bar\n" * 1_0     )
							# hidden file
							with open(data_dir / "subdir" / ".test.txt"							,     "w"     ) as f:
														f.write("bar\n" * 1_0     )

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

							return data_dir





from __future__ import annotations

from functools import lru_cache
from math import ceil

_snake_case					:		Tuple      =    100

_snake_case					:		int      =    set(range(3, NUM_PRIMES, 2))
primes.add(2)
_snake_case					:		int

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
			if prime not in primes:
						continue
			primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))







@lru_cache(maxsize=1_0_0     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							if number_to_partition < 0:
														return set()
							elif number_to_partition == 0:
														return {1}

							__snake_case		:      set[int]										=       set()
							__snake_case		:      int
							__snake_case		:      int

							for prime in primes:
														if prime > number_to_partition:
																					continue
														for sub in partition(number_to_partition - prime     ):
																					ret.add(sub * prime     )

							return ret







def     lowerCAmelCase_					( __lowerCamelCase = 5_0_0_0     ):
							for number_to_partition in range(1							,     __lowerCamelCase     ):
														if len(partition(__lowerCamelCase     )     ) > number_unique_partitions:
																					return number_to_partition
							return None


if __name__ == "__main__":
			print(f'''{solution() = }''')

