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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: List[Any]						,			a_				: List[str]):
			lowerCamelCase						:Optional[Any]						  =     str(tmp_path_factory.mktemp('''data''') / '''file.arrow''')
			dataset.map(cache_file_name=a_)
			return filename


# FILE_CONTENT + files


A__           =							"""\
    Text data.
    Second line of data."""





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Dict):
			lowerCamelCase						:int						  =     tmp_path_factory.mktemp('''data''') / '''file.txt'''
			lowerCamelCase						:Optional[int]						  =     FILE_CONTENT
			with open(a_						,			'''w''') as f:
						f.write(a_)
			return filename





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Optional[int]):
			import bza

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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Any):
			import gzip

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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Tuple):
			if datasets.config.LZ4_AVAILABLE:
						import lza.frame

						lowerCamelCase						:Union[str, Any]						  =     tmp_path_factory.mktemp('''data''') / '''file.txt.lz4'''
						lowerCamelCase						:List[Any]						  =     bytes(a_						,			'''utf-8''')
						with lza.frame.open(a_						,			'''wb''') as f:
									f.write(a_)
						return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Union[str, Any]						,			a_				: str):
			if datasets.config.PY7ZR_AVAILABLE:
						import pyazr

						lowerCamelCase						:Dict						  =     tmp_path_factory.mktemp('''data''') / '''file.txt.7z'''
						with pyazr.SevenZipFile(a_						,			'''w''') as archive:
									archive.write(a_						,			arcname=os.path.basename(a_))
						return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: int						,			a_				: Any):
			import tarfile

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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: int):
			import lzma

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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: List[Any]						,			a_				: int):
			import zipfile

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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Dict):
			if datasets.config.ZSTANDARD_AVAILABLE:
						import zstandard as zstd

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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Tuple):
			lowerCamelCase						:str						  =     tmp_path_factory.mktemp('''data''') / '''file.xml'''
			lowerCamelCase						:int						  =     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(a_						,			'''w''') as f:
						f.write(a_)
			return filename


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

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

A__           =							[
    {"""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					(   a_				: List[Any]):
			lowerCamelCase						:List[str]						  =     datasets.Dataset.from_dict(a_)
			lowerCamelCase						:Tuple						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset.arrow''')
			dataset.map(cache_file_name=a_)
			return path





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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Tuple):
			lowerCamelCase						:Optional[Any]						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset2.csv''')
			with open(a_						,			'''w'''						,			newline='''''') as f:
						lowerCamelCase						:Dict						  =     csv.DictWriter(a_						,			fieldnames=['''col_1''', '''col_2''', '''col_3'''])
						writer.writeheader()
						for item in DATA:
									writer.writerow(a_)
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: str						,			a_				: Optional[int]):
			import bza

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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Dict						,			a_				: List[str]						,			a_				: str):
			lowerCamelCase						:Optional[Any]						  =     tmp_path_factory.mktemp('''data''') / '''dataset.csv.zip'''
			with zipfile.ZipFile(a_						,			'''w''') as f:
						f.write(a_						,			arcname=os.path.basename(a_))
						f.write(a_						,			arcname=os.path.basename(a_))
			return path





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





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





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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: str):
			lowerCamelCase						:List[str]						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset.json''')
			lowerCamelCase						:int						  =     {'''data''': DATA}
			with open(a_						,			'''w''') as f:
						json.dump(a_						,			a_)
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: int):
			lowerCamelCase						:Optional[int]						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset.json''')
			lowerCamelCase						:str						  =     {'''data''': DATA_DICT_OF_LISTS}
			with open(a_						,			'''w''') as f:
						json.dump(a_						,			a_)
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: int):
			lowerCamelCase						:Optional[Any]						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset.jsonl''')
			with open(a_						,			'''w''') as f:
						for item in DATA:
									f.write(json.dumps(a_) + '''\n''')
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: List[str]):
			lowerCamelCase						:int						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset2.jsonl''')
			with open(a_						,			'''w''') as f:
						for item in DATA:
									f.write(json.dumps(a_) + '''\n''')
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Union[str, Any]):
			lowerCamelCase						:Dict						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset_312.jsonl''')
			with open(a_						,			'''w''') as f:
						for item in DATA_312:
									f.write(json.dumps(a_) + '''\n''')
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: List[Any]):
			lowerCamelCase						:Dict						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset-str.jsonl''')
			with open(a_						,			'''w''') as f:
						for item in DATA_STR:
									f.write(json.dumps(a_) + '''\n''')
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Any						,			a_				: str):
			import gzip

			lowerCamelCase						:int						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset.txt.gz''')
			with open(a_						,			'''rb''') as orig_file:
						with gzip.open(a_						,			'''wb''') as zipped_file:
									zipped_file.writelines(a_)
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: List[str]						,			a_				: str):
			import gzip

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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: str						,			a_				: Optional[Any]						,			a_				: Optional[int]):
			lowerCamelCase						:Dict						  =     tmp_path_factory.mktemp('''data''') / '''dataset.jsonl.zip'''
			with zipfile.ZipFile(a_						,			'''w''') as f:
						f.write(a_						,			arcname=os.path.basename(a_))
						f.write(a_						,			arcname=os.path.basename(a_))
			return path





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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Optional[int]						,			a_				: List[str]						,			a_				: Dict):
			lowerCamelCase						:List[Any]						  =     tmp_path_factory.mktemp('''data''') / '''dataset_with_dir.jsonl.zip'''
			with zipfile.ZipFile(a_						,			'''w''') as f:
						f.write(a_						,			arcname=os.path.join('''main_dir'''						,			os.path.basename(a_)))
						f.write(a_						,			arcname=os.path.join('''main_dir'''						,			os.path.basename(a_)))
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: List[Any]						,			a_				: Any						,			a_				: Optional[Any]):
			lowerCamelCase						:List[Any]						  =     tmp_path_factory.mktemp('''data''') / '''dataset.jsonl.tar'''
			with tarfile.TarFile(a_						,			'''w''') as f:
						f.add(a_						,			arcname=os.path.basename(a_))
						f.add(a_						,			arcname=os.path.basename(a_))
			return path





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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Dict):
			lowerCamelCase						:List[str]						  =     ['''0''', '''1''', '''2''', '''3''']
			lowerCamelCase						:str						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset.txt''')
			with open(a_						,			'''w''') as f:
						for item in data:
									f.write(item + '''\n''')
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: int):
			lowerCamelCase						:Optional[int]						  =     ['''0''', '''1''', '''2''', '''3''']
			lowerCamelCase						:Any						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset2.txt''')
			with open(a_						,			'''w''') as f:
						for item in data:
									f.write(item + '''\n''')
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: List[Any]):
			lowerCamelCase						:Optional[Any]						  =     ['''0''', '''1''', '''2''', '''3''']
			lowerCamelCase						:Any						  =     tmp_path_factory.mktemp('''data''') / '''dataset.abc'''
			with open(a_						,			'''w''') as f:
						for item in data:
									f.write(item + '''\n''')
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Optional[Any]						,			a_				: Optional[int]						,			a_				: Optional[int]):
			lowerCamelCase						:Dict						  =     tmp_path_factory.mktemp('''data''') / '''dataset.text.zip'''
			with zipfile.ZipFile(a_						,			'''w''') as f:
						f.write(a_						,			arcname=os.path.basename(a_))
						f.write(a_						,			arcname=os.path.basename(a_))
			return path





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





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: int						,			a_				: Optional[int]						,			a_				: Union[str, Any]):
			lowerCamelCase						:int						  =     tmp_path_factory.mktemp('''data''') / '''dataset.ext.zip'''
			with zipfile.ZipFile(a_						,			'''w''') as f:
						f.write(a_						,			arcname=os.path.basename('''unsupported.ext'''))
						f.write(a_						,			arcname=os.path.basename('''unsupported_2.ext'''))
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: Dict):
			lowerCamelCase						:Optional[int]						  =     '''\n'''.join(['''First''', '''Second\u2029with Unicode new line''', '''Third'''])
			lowerCamelCase						:int						  =     str(tmp_path_factory.mktemp('''data''') / '''dataset_with_unicode_new_lines.txt''')
			with open(a_						,			'''w'''						,			encoding='''utf-8''') as f:
						f.write(a_)
			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					(   a_				: Tuple						,			a_				: Union[str, Any]):
			lowerCamelCase						:Any						  =     tmp_path_factory.mktemp('''data''') / '''dataset.img.zip'''
			with zipfile.ZipFile(a_						,			'''w''') as f:
						f.write(a_						,			arcname=os.path.basename(a_))
						f.write(a_						,			arcname=os.path.basename(a_).replace('''.jpg'''						,			'''2.jpg'''))
			return path





@pytest.fixture(scope='''session''')
def  _lowerCamelCase					(   a_				: List[Any]):
			lowerCamelCase						:List[str]						  =     tmp_path_factory.mktemp('''data_dir''')

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

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

			return data_dir




def  _lowerCamelCase					(   a_				: int = 4_00_00_00):
			lowerCamelCase						:Dict						  =     [0, 1]
			lowerCamelCase						:Optional[Any]						  =     0
			while fib[i] <= n:
						fib.append(fib[i] + fib[i + 1])
						if fib[i + 2] > n:
									break
						i += 1
			lowerCamelCase						:Dict						  =     0
			for j in range(len(a_) - 1):
						if fib[j] % 2 == 0:
									total += fib[j]

			return total


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



