






from functools import lru_cache




def      lowercase__      (     __snake_case    :							int  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Tuple            =						2
					UpperCAmelCase_    :      Union[str, Any]            =						set()
					while i * i <= n:
										if n % i:
															i += 1
										else:
															n //= i
															factors.add(__snake_case  )
					if n > 1:
										factors.add(__snake_case  )
					return factors




@lru_cache
def      lowercase__      (     __snake_case    :							int  ):


					'''simple docstring'''


					return len(unique_prime_factors(__snake_case  )  )




def      lowercase__      (     __snake_case    :							list  ):


					'''simple docstring'''


					return len(set(__snake_case  )  ) in (0, 1)




def      lowercase__      (     __snake_case    :							int  ):


					'''simple docstring'''


					UpperCAmelCase_    :      List[str]            =						2

					while True:
										# Increment each value of a generated range
										UpperCAmelCase_    :      int            =						[base + i for i in range(__snake_case  )]

										# Run elements through out unique_prime_factors function
										# Append our target number to the end.
										UpperCAmelCase_    :      Optional[Any]            =						[upf_len(__snake_case  ) for x in group]
										checker.append(__snake_case  )

										# If all numbers in the list are equal, return the group variable.
										if equality(__snake_case  ):
															return group

										# Increment our base variable by 1
										base += 1




def      lowercase__      (     __snake_case    :							int = 4  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Union[str, Any]            =						run(__snake_case  )
					return results[0] if len(__snake_case  ) else None


if __name__ == "__main__":
		print(solution())














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      lowercase__      (     ):


					'''simple docstring'''


					UpperCAmelCase_    :      Tuple            =						10
					UpperCAmelCase_    :      Tuple            =						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_    :      Tuple            =						datasets.Dataset.from_dict(
					    {
					        'tokens': [['foo'] * 5] * n,
					        'labels': [[1] * 5] * n,
					        'answers': [{'answer_start': [97], 'text': ['1976']}] * 10,
					        'id': list(range(__snake_case  )  ),
					    }     ,       features=__snake_case     ,       )
					return dataset




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Optional[Any]     ,       __snake_case    :							List[str]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      str            =						str(tmp_path_factory.mktemp('data'  ) / 'file.arrow'  )
					dataset.map(cache_file_name=__snake_case  )
					return filename


# FILE_CONTENT + files


__UpperCAmelCase								=						'\\n    Text data.\n    Second line of data.'




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Optional[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[int]            =						tmp_path_factory.mktemp('data'  ) / 'file.txt'
					UpperCAmelCase_    :      Tuple            =						FILE_CONTENT
					with open(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case  )
					return filename




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							List[str]  ):


					'''simple docstring'''


					import bza

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Any  ):


					'''simple docstring'''


					import gzip

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Dict  ):


					'''simple docstring'''


					if datasets.config.LZ4_AVAILABLE:
										import lza.frame

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Tuple     ,       __snake_case    :							List[Any]  ):


					'''simple docstring'''


					if datasets.config.PY7ZR_AVAILABLE:
										import pyazr

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							List[str]     ,       __snake_case    :							List[Any]  ):


					'''simple docstring'''


					import tarfile

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							str  ):


					'''simple docstring'''


					import lzma

					UpperCAmelCase_    :      Union[str, Any]            =						tmp_path_factory.mktemp('data'  ) / 'file.txt.xz'
					UpperCAmelCase_    :      Any            =						bytes(__snake_case     ,       'utf-8'  )
					with lzma.open(__snake_case     ,       'wb'  ) as f:
										f.write(__snake_case  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Optional[int]     ,       __snake_case    :							Optional[Any]  ):


					'''simple docstring'''


					import zipfile

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Optional[Any]  ):


					'''simple docstring'''


					if datasets.config.ZSTANDARD_AVAILABLE:
										import zstandard as zstd

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Any  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Union[str, Any]            =						tmp_path_factory.mktemp('data'  ) / 'file.xml'
					UpperCAmelCase_    :      List[Any]            =						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(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case  )
					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      lowercase__      (     ):


					'''simple docstring'''


					return DATA_DICT_OF_LISTS




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							int  ):


					'''simple docstring'''


					UpperCAmelCase_    :      List[Any]            =						datasets.Dataset.from_dict(__snake_case  )
					UpperCAmelCase_    :      Optional[Any]            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.arrow'  )
					dataset.map(cache_file_name=__snake_case  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							List[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[int]            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.sqlite'  )
					with contextlib.closing(sqlitea.connect(__snake_case  )  ) as con:
										UpperCAmelCase_    :      List[Any]            =						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      lowercase__      (     __snake_case    :							Union[str, Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[Any]            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.csv'  )
					with open(__snake_case     ,       'w'     ,       newline=''  ) as f:
										UpperCAmelCase_    :      Tuple            =						csv.DictWriter(__snake_case     ,       fieldnames=['col_1', 'col_2', 'col_3']  )
										writer.writeheader()
										for item in DATA:
															writer.writerow(__snake_case  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Optional[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Tuple            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset2.csv'  )
					with open(__snake_case     ,       'w'     ,       newline=''  ) as f:
										UpperCAmelCase_    :      Optional[Any]            =						csv.DictWriter(__snake_case     ,       fieldnames=['col_1', 'col_2', 'col_3']  )
										writer.writeheader()
										for item in DATA:
															writer.writerow(__snake_case  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							str     ,       __snake_case    :							Any  ):


					'''simple docstring'''


					import bza

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							List[str]     ,       __snake_case    :							Tuple     ,       __snake_case    :							Optional[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      List[Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset.csv.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
										f.write(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							str     ,       __snake_case    :							Optional[int]     ,       __snake_case    :							Tuple  ):


					'''simple docstring'''


					UpperCAmelCase_    :      List[Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset.csv.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.basename(csv_path.replace('.csv'     ,       '.CSV'  )  )  )
										f.write(__snake_case     ,       arcname=os.path.basename(csva_path.replace('.csv'     ,       '.CSV'  )  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Tuple     ,       __snake_case    :							int     ,       __snake_case    :							str  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset_with_dir.csv.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.join('main_dir'     ,       os.path.basename(__snake_case  )  )  )
										f.write(__snake_case     ,       arcname=os.path.join('main_dir'     ,       os.path.basename(__snake_case  )  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Union[str, Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      int            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.parquet'  )
					UpperCAmelCase_    :      Dict            =						pa.schema(
					    {
					        'col_1': pa.string(),
					        'col_2': pa.intaa(),
					        'col_3': pa.floataa(),
					    }  )
					with open(__snake_case     ,       'wb'  ) as f:
										UpperCAmelCase_    :      List[Any]            =						pq.ParquetWriter(__snake_case     ,       schema=__snake_case  )
										UpperCAmelCase_    :      Any            =						pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(__snake_case  )  )] for k in DATA[0]}     ,       schema=__snake_case  )
										writer.write_table(__snake_case  )
										writer.close()
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Union[str, Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Tuple            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.json'  )
					UpperCAmelCase_    :      Optional[int]            =						{'data': DATA}
					with open(__snake_case     ,       'w'  ) as f:
										json.dump(__snake_case     ,       __snake_case  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							List[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Tuple            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.json'  )
					UpperCAmelCase_    :      Tuple            =						{'data': DATA_DICT_OF_LISTS}
					with open(__snake_case     ,       'w'  ) as f:
										json.dump(__snake_case     ,       __snake_case  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Optional[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Dict            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.jsonl'  )
					with open(__snake_case     ,       'w'  ) as f:
										for item in DATA:
															f.write(json.dumps(__snake_case  ) + '\n'  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							str  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Union[str, Any]            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset2.jsonl'  )
					with open(__snake_case     ,       'w'  ) as f:
										for item in DATA:
															f.write(json.dumps(__snake_case  ) + '\n'  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							int  ):


					'''simple docstring'''


					UpperCAmelCase_    :      int            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset_312.jsonl'  )
					with open(__snake_case     ,       'w'  ) as f:
										for item in DATA_312:
															f.write(json.dumps(__snake_case  ) + '\n'  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							str  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[int]            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset-str.jsonl'  )
					with open(__snake_case     ,       'w'  ) as f:
										for item in DATA_STR:
															f.write(json.dumps(__snake_case  ) + '\n'  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Dict     ,       __snake_case    :							Dict  ):


					'''simple docstring'''


					import gzip

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




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							int     ,       __snake_case    :							Any  ):


					'''simple docstring'''


					import gzip

					UpperCAmelCase_    :      Dict            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.jsonl.gz'  )
					with open(__snake_case     ,       'rb'  ) as orig_file:
										with gzip.open(__snake_case     ,       'wb'  ) as zipped_file:
															zipped_file.writelines(__snake_case  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Optional[Any]     ,       __snake_case    :							Dict     ,       __snake_case    :							Optional[int]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      int            =						tmp_path_factory.mktemp('data'  ) / 'dataset.jsonl.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
										f.write(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Optional[Any]     ,       __snake_case    :							str     ,       __snake_case    :							Dict     ,       __snake_case    :							Union[str, Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      str            =						tmp_path_factory.mktemp('data'  ) / 'dataset_nested.jsonl.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.join('nested'     ,       os.path.basename(__snake_case  )  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Dict     ,       __snake_case    :							Union[str, Any]     ,       __snake_case    :							Tuple  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[int]            =						tmp_path_factory.mktemp('data'  ) / 'dataset_with_dir.jsonl.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.join('main_dir'     ,       os.path.basename(__snake_case  )  )  )
										f.write(__snake_case     ,       arcname=os.path.join('main_dir'     ,       os.path.basename(__snake_case  )  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Tuple     ,       __snake_case    :							str     ,       __snake_case    :							Union[str, Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      List[Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset.jsonl.tar'
					with tarfile.TarFile(__snake_case     ,       'w'  ) as f:
										f.add(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
										f.add(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							str     ,       __snake_case    :							Any     ,       __snake_case    :							Any     ,       __snake_case    :							List[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      List[Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset_nested.jsonl.tar'
					with tarfile.TarFile(__snake_case     ,       'w'  ) as f:
										f.add(__snake_case     ,       arcname=os.path.join('nested'     ,       os.path.basename(__snake_case  )  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							List[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Any            =						['0', '1', '2', '3']
					UpperCAmelCase_    :      Dict            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset.txt'  )
					with open(__snake_case     ,       'w'  ) as f:
										for item in data:
															f.write(item + '\n'  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							List[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[Any]            =						['0', '1', '2', '3']
					UpperCAmelCase_    :      Optional[int]            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset2.txt'  )
					with open(__snake_case     ,       'w'  ) as f:
										for item in data:
															f.write(item + '\n'  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Tuple  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Dict            =						['0', '1', '2', '3']
					UpperCAmelCase_    :      List[str]            =						tmp_path_factory.mktemp('data'  ) / 'dataset.abc'
					with open(__snake_case     ,       'w'  ) as f:
										for item in data:
															f.write(item + '\n'  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Any     ,       __snake_case    :							Union[str, Any]     ,       __snake_case    :							List[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      List[Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset.text.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
										f.write(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Dict     ,       __snake_case    :							str     ,       __snake_case    :							Any  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Union[str, Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset_with_dir.text.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.join('main_dir'     ,       os.path.basename(__snake_case  )  )  )
										f.write(__snake_case     ,       arcname=os.path.join('main_dir'     ,       os.path.basename(__snake_case  )  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Union[str, Any]     ,       __snake_case    :							str     ,       __snake_case    :							Optional[int]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Union[str, Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset.ext.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.basename('unsupported.ext'  )  )
										f.write(__snake_case     ,       arcname=os.path.basename('unsupported_2.ext'  )  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Dict  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Tuple            =						'\n'.join(['First', 'Second\u2029with Unicode new line', 'Third']  )
					UpperCAmelCase_    :      Dict            =						str(tmp_path_factory.mktemp('data'  ) / 'dataset_with_unicode_new_lines.txt'  )
					with open(__snake_case     ,       'w'     ,       encoding='utf-8'  ) as f:
										f.write(__snake_case  )
					return path




@pytest.fixture(scope='session'  )
def      lowercase__      (     ):


					'''simple docstring'''


					return os.path.join('tests'     ,       'features'     ,       'data'     ,       'test_image_rgb.jpg'  )




@pytest.fixture(scope='session'  )
def      lowercase__      (     ):


					'''simple docstring'''


					return os.path.join('tests'     ,       'features'     ,       'data'     ,       'test_audio_44100.wav'  )




@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							str     ,       __snake_case    :							List[str]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[Any]            =						tmp_path_factory.mktemp('data'  ) / 'dataset.img.zip'
					with zipfile.ZipFile(__snake_case     ,       'w'  ) as f:
										f.write(__snake_case     ,       arcname=os.path.basename(__snake_case  )  )
										f.write(__snake_case     ,       arcname=os.path.basename(__snake_case  ).replace('.jpg'     ,       '2.jpg'  )  )
					return path






@pytest.fixture(scope='session'  )
def      lowercase__      (     __snake_case    :							Any  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[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






