






from typing import List

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCAmelCase								=						logging.get_logger(__name__)

__UpperCAmelCase								=						{
    'snap-research/efficientformer-l1-300': (
        'https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json'
    ),
}



class   lowerCamelCase      (_snake_case			):







		'''simple docstring'''



		_snake_case    :    Optional[int]       						=  '''efficientformer'''



		def __init__(							self				,		_UpperCamelCase = [3, 2, 6, 4]				,		_UpperCamelCase = [4_8, 9_6, 2_2_4, 4_4_8]				,		_UpperCamelCase = [True, True, True, True]				,		_UpperCamelCase = 4_4_8				,		_UpperCamelCase = 3_2				,		_UpperCamelCase = 4				,		_UpperCamelCase = 7				,		_UpperCamelCase = 5				,		_UpperCamelCase = 8				,		_UpperCamelCase = 4				,		_UpperCamelCase = 0.0				,		_UpperCamelCase = 1_6				,		_UpperCamelCase = 3				,		_UpperCamelCase = 3				,		_UpperCamelCase = 3				,		_UpperCamelCase = 2				,		_UpperCamelCase = 1				,		_UpperCamelCase = 0.0				,		_UpperCamelCase = 1				,		_UpperCamelCase = True				,		_UpperCamelCase = True				,		_UpperCamelCase = 1E-5				,		_UpperCamelCase = "gelu"				,		_UpperCamelCase = 0.02				,		_UpperCamelCase = 1E-12				,		_UpperCamelCase = 2_2_4				,		_UpperCamelCase = 1E-05				,		**_UpperCamelCase				,		)	->							None:
							super().__init__(**_UpperCamelCase   )

							UpperCAmelCase_    :      int            =						hidden_act
							UpperCAmelCase_    :      Union[str, Any]            =						hidden_dropout_prob
							UpperCAmelCase_    :      Tuple            =						hidden_sizes
							UpperCAmelCase_    :      Union[str, Any]            =						num_hidden_layers
							UpperCAmelCase_    :      List[str]            =						num_attention_heads
							UpperCAmelCase_    :      List[Any]            =						initializer_range
							UpperCAmelCase_    :      int            =						layer_norm_eps
							UpperCAmelCase_    :      List[str]            =						patch_size
							UpperCAmelCase_    :      Union[str, Any]            =						num_channels
							UpperCAmelCase_    :      Optional[Any]            =						depths
							UpperCAmelCase_    :      List[Any]            =						mlp_expansion_ratio
							UpperCAmelCase_    :      List[str]            =						downsamples
							UpperCAmelCase_    :      List[Any]            =						dim
							UpperCAmelCase_    :      Tuple            =						key_dim
							UpperCAmelCase_    :      Optional[int]            =						attention_ratio
							UpperCAmelCase_    :      str            =						resolution
							UpperCAmelCase_    :      Dict            =						pool_size
							UpperCAmelCase_    :      Union[str, Any]            =						downsample_patch_size
							UpperCAmelCase_    :      List[str]            =						downsample_stride
							UpperCAmelCase_    :      List[str]            =						downsample_pad
							UpperCAmelCase_    :      Any            =						drop_path_rate
							UpperCAmelCase_    :      Dict            =						num_metaad_blocks
							UpperCAmelCase_    :      Dict            =						distillation
							UpperCAmelCase_    :      int            =						use_layer_scale
							UpperCAmelCase_    :      Any            =						layer_scale_init_value
							UpperCAmelCase_    :      Any            =						image_size
							UpperCAmelCase_    :      Dict            =						batch_norm_eps














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






