
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__ (  )						->		List[Any]:
       UpperCamelCase_											=				10
       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""": [97], """text""": ["""1976"""]}] * 10,
               """id""": list(range(__lowerCAmelCase   )   ),
           }		,					features=__lowerCAmelCase		,					)
       return dataset




@pytest.fixture(scope="""session"""   )
def  lowerCamelCase__ (  a__     :     Optional[Any]		,					a__     :     Optional[int]   )						->		Optional[int]:
       UpperCamelCase_											=				str(tmp_path_factory.mktemp("""data"""   ) / """file.arrow"""   )
       dataset.map(cache_file_name=__lowerCAmelCase   )
       return filename


# FILE_CONTENT + files


_A		     =    '''\
    Text data.
    Second line of data.'''




@pytest.fixture(scope="""session"""   )
def  lowerCamelCase__ (  a__     :     Dict   )						->		List[Any]:
       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__     :     Union[str, Any]   )						->		str:
       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]   )						->		str:
       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__     :     Any   )						->		Tuple:
       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__     :     List[str]		,					a__     :     Dict   )						->		Any:
       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__     :     Dict		,					a__     :     Tuple   )						->		str:
       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__     :     Dict   )						->		List[str]:
       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__     :     Dict		,					a__     :     List[str]   )						->		Optional[Any]:
       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__     :     Optional[int]   )						->		int:
       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__     :     Optional[Any]   )						->		Optional[int]:
       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


_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__ (  )						->		Optional[Any]:
       return DATA_DICT_OF_LISTS




@pytest.fixture(scope="""session"""   )
def  lowerCamelCase__ (  a__     :     Optional[int]   )						->		Tuple:
       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__     :     Optional[Any]   )						->		Dict:
       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__     :     Any   )						->		Dict:
       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__     :     List[str]   )						->		Tuple:
       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__     :     Dict		,					a__     :     Tuple   )						->		Any:
       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__     :     List[str]		,					a__     :     str		,					a__     :     Optional[int]   )						->		List[Any]:
       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__     :     Dict		,					a__     :     str		,					a__     :     Optional[int]   )						->		Union[str, Any]:
       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__     :     List[Any]		,					a__     :     List[Any]		,					a__     :     Any   )						->		Any:
       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__     :     int   )						->		List[str]:
       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__     :     Union[str, Any]   )						->		List[str]:
       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__     :     int   )						->		List[Any]:
       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__     :     Tuple   )						->		Union[str, Any]:
       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__     :     str   )						->		Dict:
       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__     :     int   )						->		List[str]:
       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__     :     Optional[Any]   )						->		Optional[Any]:
       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__     :     List[Any]		,					a__     :     List[str]   )						->		Union[str, Any]:
       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__     :     Any		,					a__     :     int   )						->		str:
       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__     :     Tuple		,					a__     :     Dict		,					a__     :     List[Any]   )						->		Optional[Any]:
       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__     :     int		,					a__     :     str		,					a__     :     Optional[Any]		,					a__     :     List[Any]   )						->		Any:
       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__     :     Optional[Any]		,					a__     :     Tuple		,					a__     :     Dict   )						->		int:
       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__     :     Dict		,					a__     :     int		,					a__     :     Any   )						->		List[Any]:
       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__     :     Optional[Any]		,					a__     :     List[Any]		,					a__     :     int		,					a__     :     List[Any]   )						->		str:
       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__     :     List[str]   )						->		Optional[int]:
       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__     :     List[str]   )						->		Union[str, Any]:
       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__     :     List[str]   )						->		List[Any]:
       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__     :     Union[str, Any]		,					a__     :     List[Any]		,					a__     :     Union[str, Any]   )						->		Dict:
       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__     :     str		,					a__     :     Dict		,					a__     :     List[Any]   )						->		Any:
       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__     :     Union[str, Any]		,					a__     :     Optional[Any]		,					a__     :     Optional[Any]   )						->		List[str]:
       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__     :     Union[str, Any]   )						->		Dict:
       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__ (  )						->		List[Any]:
       return os.path.join("""tests"""		,					"""features"""		,					"""data"""		,					"""test_image_rgb.jpg"""   )




@pytest.fixture(scope="""session"""   )
def  lowerCamelCase__ (  )						->		int:
       return os.path.join("""tests"""		,					"""features"""		,					"""data"""		,					"""test_audio_44100.wav"""   )




@pytest.fixture(scope="""session"""   )
def  lowerCamelCase__ (  a__     :     str		,					a__     :     Any   )						->		Any:
       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__     :     Union[str, Any]   )						->		str:
       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""" * 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







import argparse


snake_case							:       int     			=      '''docs/source/_static/js/custom.js'''






def 							__lowercase   ( __lowerCAmelCase							:				Optional[Any]   ):
							with open(__lowerCAmelCase					,    encoding='utf-8'					,    newline='\n'   ) as f:
														a__             =     f.readlines()
							a__             =     0

							# First let's put the right version
							while not lines[index].startswith('const stableVersion ='   ):
														index += 1
							a__             =     F'const stableVersion = "v{version}"\n'

							# Then update the dictionary
							while not lines[index].startswith('const versionMapping = {'   ):
														index += 1

							# We go until the end
							while not lines[index].startswith('}'   ):
														index += 1
							# We add the new version at the end
							lines[index - 1] += F'    "v{version}": "v{version}",\n'

							with open(__lowerCAmelCase					,    'w'					,    encoding='utf-8'					,    newline='\n'   ) as f:
														f.writelines(__lowerCAmelCase   )


if __name__ == "__main__":
						snake_case							:       Optional[Any]     			=      argparse.ArgumentParser()
						parser.add_argument('''--version''', help='''Release version.''')
						snake_case							:       Optional[int]     			=      parser.parse_args()
						update_custom_js(args.version)




