


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





	"""simple docstring"""







	A             =					10
	A             =					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"""    ),
	    }    )
	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  List[str]				,       UpperCamelCase__:  Dict    )			-> Dict:





	"""simple docstring"""







	A             =					str(tmp_path_factory.mktemp("""data"""    ) / """file.arrow"""    )
	dataset.map(cache_file_name=UpperCamelCase__    )
	return filename


# FILE_CONTENT + files


_lowercase							:   List[str]						=						"\\n    Text data.\n    Second line of data."





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Dict    )			-> Any:





	"""simple docstring"""







	A             =					tmp_path_factory.mktemp("""data"""    ) / """file.txt"""
	A             =					FILE_CONTENT
	with open(UpperCamelCase__				,       """w"""    ) as f:
		f.write(UpperCamelCase__    )
	return filename





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]    )			-> int:





	"""simple docstring"""







	import bza

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





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Tuple    )			-> int:





	"""simple docstring"""







	import gzip

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





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Any    )			-> Optional[int]:





	"""simple docstring"""







	if datasets.config.LZ4_AVAILABLE:
		import lza.frame

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





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]				,       UpperCamelCase__:  Union[str, Any]    )			-> Any:





	"""simple docstring"""







	if datasets.config.PY7ZR_AVAILABLE:
		import pyazr

		A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]				,       UpperCamelCase__:  Union[str, Any]    )			-> Optional[int]:





	"""simple docstring"""







	import tarfile

	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  str    )			-> List[Any]:





	"""simple docstring"""







	import lzma

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





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]				,       UpperCamelCase__:  Optional[int]    )			-> int:





	"""simple docstring"""







	import zipfile

	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Any    )			-> List[str]:





	"""simple docstring"""







	if datasets.config.ZSTANDARD_AVAILABLE:
		import zstandard as zstd

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





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Dict    )			-> str:





	"""simple docstring"""







	A             =					tmp_path_factory.mktemp("""data"""    ) / """file.xml"""
	A             =					textwrap.dedent(
	    """\
    <?xml version=\"1.0\" encoding=\"UTF-8\" ?>
    <tmx version=\"1.4\">
      <header segtype=\"sentence\" srclang=\"ca\" />
      <body>
        <tu>
          <tuv xml:lang=\"ca\"><seg>Contingut 1</seg></tuv>
          <tuv xml:lang=\"en\"><seg>Content 1</seg></tuv>
        </tu>
        <tu>
          <tuv xml:lang=\"ca\"><seg>Contingut 2</seg></tuv>
          <tuv xml:lang=\"en\"><seg>Content 2</seg></tuv>
        </tu>
        <tu>
          <tuv xml:lang=\"ca\"><seg>Contingut 3</seg></tuv>
          <tuv xml:lang=\"en\"><seg>Content 3</seg></tuv>
        </tu>
        <tu>
          <tuv xml:lang=\"ca\"><seg>Contingut 4</seg></tuv>
          <tuv xml:lang=\"en\"><seg>Content 4</seg></tuv>
        </tu>
        <tu>
          <tuv xml:lang=\"ca\"><seg>Contingut 5</seg></tuv>
          <tuv xml:lang=\"en\"><seg>Content 5</seg></tuv>
        </tu>
      </body>
    </tmx>"""    )
	with open(UpperCamelCase__				,       """w"""    ) as f:
		f.write(UpperCamelCase__    )
	return filename


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

_lowercase							:   List[str]						=						[
    {"col_3": 0.0, "col_1": "0", "col_2": 0},
    {"col_3": 1.0, "col_1": "1", "col_2": 1},
]

_lowercase							:   List[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					( )			-> str:





	"""simple docstring"""







	return DATA_DICT_OF_LISTS





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]    )			-> List[str]:





	"""simple docstring"""







	A             =					datasets.Dataset.from_dict(UpperCamelCase__    )
	A             =					str(tmp_path_factory.mktemp("""data"""    ) / """dataset.arrow"""    )
	dataset.map(cache_file_name=UpperCamelCase__    )
	return path





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Dict    )			-> Any:





	"""simple docstring"""







	A             =					str(tmp_path_factory.mktemp("""data"""    ) / """dataset.sqlite"""    )
	with contextlib.closing(sqlitea.connect(UpperCamelCase__    )    ) as con:
		A             =					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					( UpperCamelCase__:  List[Any]    )			-> Optional[int]:





	"""simple docstring"""







	A             =					str(tmp_path_factory.mktemp("""data"""    ) / """dataset.csv"""    )
	with open(UpperCamelCase__				,       """w"""				,       newline=""""""    ) as f:
		A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Optional[int]    )			-> Union[str, Any]:





	"""simple docstring"""







	A             =					str(tmp_path_factory.mktemp("""data"""    ) / """dataset2.csv"""    )
	with open(UpperCamelCase__				,       """w"""				,       newline=""""""    ) as f:
		A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  str				,       UpperCamelCase__:  int    )			-> str:





	"""simple docstring"""







	import bza

	A             =					tmp_path_factory.mktemp("""data"""    ) / """dataset.csv.bz2"""
	with open(UpperCamelCase__				,       """rb"""    ) as f:
		A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Optional[int]				,       UpperCamelCase__:  str				,       UpperCamelCase__:  Any    )			-> Any:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  List[str]				,       UpperCamelCase__:  Union[str, Any]				,       UpperCamelCase__:  Optional[int]    )			-> Optional[int]:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  List[str]				,       UpperCamelCase__:  int				,       UpperCamelCase__:  Tuple    )			-> int:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  List[Any]    )			-> Optional[int]:





	"""simple docstring"""







	A             =					str(tmp_path_factory.mktemp("""data"""    ) / """dataset.parquet"""    )
	A             =					pa.schema(
	    {
	        """col_1""": pa.string(),
	        """col_2""": pa.intaa(),
	        """col_3""": pa.floataa(),
	    }    )
	with open(UpperCamelCase__				,       """wb"""    ) as f:
		A             =					pq.ParquetWriter(UpperCamelCase__				,       schema=UpperCamelCase__    )
		A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Any    )			-> List[Any]:





	"""simple docstring"""







	A             =					str(tmp_path_factory.mktemp("""data"""    ) / """dataset.json"""    )
	A             =					{"""data""": DATA}
	with open(UpperCamelCase__				,       """w"""    ) as f:
		json.dump(UpperCamelCase__				,       UpperCamelCase__    )
	return path





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Union[str, Any]    )			-> str:





	"""simple docstring"""







	A             =					str(tmp_path_factory.mktemp("""data"""    ) / """dataset.json"""    )
	A             =					{"""data""": DATA_DICT_OF_LISTS}
	with open(UpperCamelCase__				,       """w"""    ) as f:
		json.dump(UpperCamelCase__				,       UpperCamelCase__    )
	return path





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[int]    )			-> str:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Any    )			-> Union[str, Any]:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  int    )			-> Tuple:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Optional[int]    )			-> Dict:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Union[str, Any]				,       UpperCamelCase__:  Any    )			-> Optional[Any]:





	"""simple docstring"""







	import gzip

	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  str				,       UpperCamelCase__:  List[str]    )			-> Union[str, Any]:





	"""simple docstring"""







	import gzip

	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Dict				,       UpperCamelCase__:  Any				,       UpperCamelCase__:  Optional[Any]    )			-> Optional[int]:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Tuple				,       UpperCamelCase__:  str				,       UpperCamelCase__:  Dict				,       UpperCamelCase__:  Any    )			-> Optional[int]:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]				,       UpperCamelCase__:  int				,       UpperCamelCase__:  Dict    )			-> List[Any]:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Dict				,       UpperCamelCase__:  Union[str, Any]				,       UpperCamelCase__:  List[str]    )			-> Optional[int]:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  str				,       UpperCamelCase__:  int				,       UpperCamelCase__:  str				,       UpperCamelCase__:  int    )			-> List[str]:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  int    )			-> Union[str, Any]:





	"""simple docstring"""







	A             =					["""0""", """1""", """2""", """3"""]
	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Union[str, Any]    )			-> List[Any]:





	"""simple docstring"""







	A             =					["""0""", """1""", """2""", """3"""]
	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Union[str, Any]    )			-> Any:





	"""simple docstring"""







	A             =					["""0""", """1""", """2""", """3"""]
	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  int				,       UpperCamelCase__:  Union[str, Any]				,       UpperCamelCase__:  Optional[Any]    )			-> Dict:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Tuple				,       UpperCamelCase__:  int				,       UpperCamelCase__:  Any    )			-> Optional[int]:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  int				,       UpperCamelCase__:  Any				,       UpperCamelCase__:  Tuple    )			-> int:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  Tuple    )			-> Dict:





	"""simple docstring"""







	A             =					"""\n""".join(["""First""", """Second\u2029with Unicode new line""", """Third"""]    )
	A             =					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 	_lowerCAmelCase					( )			-> Dict:





	"""simple docstring"""







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





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( )			-> List[Any]:





	"""simple docstring"""







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





@pytest.fixture(scope="""session"""    )
def 	_lowerCAmelCase					( UpperCamelCase__:  str				,       UpperCamelCase__:  Tuple    )			-> Tuple:





	"""simple docstring"""







	A             =					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 	_lowerCAmelCase					( UpperCamelCase__:  int    )			-> Dict:





	"""simple docstring"""







	A             =					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







_lowercase							:   Dict						=						{
    "Pillow": "Pillow",
    "accelerate": "accelerate>=0.11.0",
    "compel": "compel==0.1.8",
    "black": "black~=23.1",
    "datasets": "datasets",
    "filelock": "filelock",
    "flax": "flax>=0.4.1",
    "hf-doc-builder": "hf-doc-builder>=0.3.0",
    "huggingface-hub": "huggingface-hub>=0.13.2",
    "requests-mock": "requests-mock==1.10.0",
    "importlib_metadata": "importlib_metadata",
    "invisible-watermark": "invisible-watermark",
    "isort": "isort>=5.5.4",
    "jax": "jax>=0.2.8,!=0.3.2",
    "jaxlib": "jaxlib>=0.1.65",
    "Jinja2": "Jinja2",
    "k-diffusion": "k-diffusion>=0.0.12",
    "torchsde": "torchsde",
    "note_seq": "note_seq",
    "librosa": "librosa",
    "numpy": "numpy",
    "omegaconf": "omegaconf",
    "parameterized": "parameterized",
    "protobuf": "protobuf>=3.20.3,<4",
    "pytest": "pytest",
    "pytest-timeout": "pytest-timeout",
    "pytest-xdist": "pytest-xdist",
    "ruff": "ruff>=0.0.241",
    "safetensors": "safetensors",
    "sentencepiece": "sentencepiece>=0.1.91,!=0.1.92",
    "scipy": "scipy",
    "onnx": "onnx",
    "regex": "regex!=2019.12.17",
    "requests": "requests",
    "tensorboard": "tensorboard",
    "torch": "torch>=1.4",
    "torchvision": "torchvision",
    "transformers": "transformers>=4.25.1",
    "urllib3": "urllib3<=2.0.0",
}



