






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'''





							_UpperCAmelCase					=      1_0
							_UpperCAmelCase					=      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					=      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__			(      a__:		List[str]      ,  a__:		str	)  ->		Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase					=      str(tmp_path_factory.mktemp('data'	) / 'file.arrow'	)
							dataset.map(cache_file_name=__lowerCAmelCase	)
							return filename


# FILE_CONTENT + files


lowerCAmelCase__  :List[str]             =							'''\
    Text data.
    Second line of data.'''

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		Tuple	)  ->		Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase					=      tmp_path_factory.mktemp('data'	) / '''file.txt'''
							_UpperCAmelCase					=      FILE_CONTENT
							with open(__lowerCAmelCase      ,  'w'	) as f:
														f.write(__lowerCAmelCase	)
							return filename

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		List[str]	)  ->		Optional[int]:


							'''simple docstring'''





							import bza

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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		Union[str, Any]	)  ->		Dict:


							'''simple docstring'''





							import gzip

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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		int	)  ->		int:


							'''simple docstring'''





							if datasets.config.LZ4_AVAILABLE:
														import lza.frame

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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		int      ,  a__:		Union[str, Any]	)  ->		Optional[Any]:


							'''simple docstring'''





							if datasets.config.PY7ZR_AVAILABLE:
														import pyazr

														_UpperCAmelCase					=      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__			(      a__:		Any      ,  a__:		List[str]	)  ->		Optional[Any]:


							'''simple docstring'''





							import tarfile

							_UpperCAmelCase					=      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__			(      a__:		Optional[Any]	)  ->		str:


							'''simple docstring'''





							import lzma

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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		Optional[int]      ,  a__:		Optional[int]	)  ->		List[str]:


							'''simple docstring'''





							import zipfile

							_UpperCAmelCase					=      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__			(      a__:		Tuple	)  ->		int:


							'''simple docstring'''





							if datasets.config.ZSTANDARD_AVAILABLE:
														import zstandard as zstd

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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		Any	)  ->		int:


							'''simple docstring'''





							_UpperCAmelCase					=      tmp_path_factory.mktemp('data'	) / '''file.xml'''
							_UpperCAmelCase					=      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


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

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

lowerCAmelCase__  :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__			(      )  ->		int:


							'''simple docstring'''





							return DATA_DICT_OF_LISTS

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		int	)  ->		Tuple:


							'''simple docstring'''





							_UpperCAmelCase					=      datasets.Dataset.from_dict(__lowerCAmelCase	)
							_UpperCAmelCase					=      str(tmp_path_factory.mktemp('data'	) / 'dataset.arrow'	)
							dataset.map(cache_file_name=__lowerCAmelCase	)
							return path

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		int	)  ->		Dict:


							'''simple docstring'''





							_UpperCAmelCase					=      str(tmp_path_factory.mktemp('data'	) / 'dataset.sqlite'	)
							with contextlib.closing(sqlitea.connect(__lowerCAmelCase	)	) as con:
														_UpperCAmelCase					=      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]	)  ->		List[str]:


							'''simple docstring'''





							_UpperCAmelCase					=      str(tmp_path_factory.mktemp('data'	) / 'dataset.csv'	)
							with open(__lowerCAmelCase      ,  'w'      ,  newline=''	) as f:
														_UpperCAmelCase					=      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__			(      a__:		Optional[Any]	)  ->		int:


							'''simple docstring'''





							_UpperCAmelCase					=      str(tmp_path_factory.mktemp('data'	) / 'dataset2.csv'	)
							with open(__lowerCAmelCase      ,  'w'      ,  newline=''	) as f:
														_UpperCAmelCase					=      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__			(      a__:		str      ,  a__:		int	)  ->		Union[str, Any]:


							'''simple docstring'''





							import bza

							_UpperCAmelCase					=      tmp_path_factory.mktemp('data'	) / '''dataset.csv.bz2'''
							with open(__lowerCAmelCase      ,  'rb'	) as f:
														_UpperCAmelCase					=      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__			(      a__:		Any      ,  a__:		List[Any]      ,  a__:		Any	)  ->		Tuple:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Tuple      ,  a__:		Optional[int]      ,  a__:		Optional[int]	)  ->		Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Union[str, Any]      ,  a__:		List[str]      ,  a__:		Dict	)  ->		str:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		List[str]	)  ->		List[Any]:


							'''simple docstring'''





							_UpperCAmelCase					=      str(tmp_path_factory.mktemp('data'	) / 'dataset.parquet'	)
							_UpperCAmelCase					=      pa.schema(
							    {
							        'col_1': pa.string(),
							        'col_2': pa.intaa(),
							        'col_3': pa.floataa(),
							    }	)
							with open(__lowerCAmelCase      ,  'wb'	) as f:
														_UpperCAmelCase					=      pq.ParquetWriter(__lowerCAmelCase      ,  schema=__lowerCAmelCase	)
														_UpperCAmelCase					=      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__			(      a__:		Optional[int]	)  ->		Optional[int]:


							'''simple docstring'''





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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		Optional[int]	)  ->		str:


							'''simple docstring'''





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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		Optional[int]	)  ->		int:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		List[str]	)  ->		Optional[Any]:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Optional[Any]	)  ->		Dict:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Union[str, Any]	)  ->		Any:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Optional[int]      ,  a__:		Dict	)  ->		int:


							'''simple docstring'''





							import gzip

							_UpperCAmelCase					=      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__			(      a__:		Dict      ,  a__:		Optional[Any]	)  ->		List[Any]:


							'''simple docstring'''





							import gzip

							_UpperCAmelCase					=      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__			(      a__:		str      ,  a__:		Any      ,  a__:		List[str]	)  ->		Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		str      ,  a__:		Any      ,  a__:		Dict      ,  a__:		int	)  ->		List[str]:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Tuple      ,  a__:		Any      ,  a__:		List[Any]	)  ->		Tuple:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Union[str, Any]      ,  a__:		Optional[Any]      ,  a__:		List[str]	)  ->		List[str]:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Any      ,  a__:		Optional[int]      ,  a__:		Tuple      ,  a__:		Any	)  ->		Any:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		str	)  ->		Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase					=      ['''0''', '''1''', '''2''', '''3''']
							_UpperCAmelCase					=      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__			(      a__:		Tuple	)  ->		int:


							'''simple docstring'''





							_UpperCAmelCase					=      ['''0''', '''1''', '''2''', '''3''']
							_UpperCAmelCase					=      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__			(      a__:		Union[str, Any]	)  ->		List[Any]:


							'''simple docstring'''





							_UpperCAmelCase					=      ['''0''', '''1''', '''2''', '''3''']
							_UpperCAmelCase					=      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__			(      a__:		Tuple      ,  a__:		Union[str, Any]      ,  a__:		List[str]	)  ->		Dict:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		List[str]      ,  a__:		str      ,  a__:		Optional[Any]	)  ->		Dict:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		List[Any]      ,  a__:		int      ,  a__:		Tuple	)  ->		Tuple:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Optional[int]	)  ->		Union[str, Any]:


							'''simple docstring'''





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


							'''simple docstring'''





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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      )  ->		Optional[int]:


							'''simple docstring'''





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

@pytest.fixture(scope='session'	)
def 	lowerCAmelCase__			(      a__:		Dict      ,  a__:		Any	)  ->		Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase					=      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__			(      a__:		Optional[int]	)  ->		Union[str, Any]:


							'''simple docstring'''





							_UpperCAmelCase					=      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 typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase__  :Any             =							{'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']}

try:
		if not is_sentencepiece_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCAmelCase__  :Optional[Any]             =							['''XGLMTokenizer''']

try:
		if not is_tokenizers_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCAmelCase__  :str             =							['''XGLMTokenizerFast''']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCAmelCase__  :List[str]             =							[
		    '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''XGLMForCausalLM''',
		    '''XGLMModel''',
		    '''XGLMPreTrainedModel''',
		]


try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCAmelCase__  :str             =							[
		    '''FlaxXGLMForCausalLM''',
		    '''FlaxXGLMModel''',
		    '''FlaxXGLMPreTrainedModel''',
		]


try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCAmelCase__  :List[Any]             =							[
		    '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''TFXGLMForCausalLM''',
		    '''TFXGLMModel''',
		    '''TFXGLMPreTrainedModel''',
		]


if TYPE_CHECKING:
		from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig

		try:
				if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_xglm import XGLMTokenizer

		try:
				if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_xglm_fast import XGLMTokenizerFast

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_xglm import (
				    TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFXGLMForCausalLM,
				    TFXGLMModel,
				    TFXGLMPreTrainedModel,
				)


else:
		import sys

		lowerCAmelCase__  :Any             =							_LazyModule(__name__, globals()['''__file__'''], _import_structure)
