






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       _SCREAMING_SNAKE_CASE (							)				->						int:
       _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(__snake_case ) ),
           }   ,      features=__snake_case   ,      )
       return dataset




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						int:
       _UpperCAmelCase							=    str(tmp_path_factory.mktemp("""data""" ) / """file.arrow""" )
       dataset.map(cache_file_name=__snake_case )
       return filename


# FILE_CONTENT + files


__a:     int   					=					'''\
    Text data.
    Second line of data.'''




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Dict:
       _UpperCAmelCase							=    tmp_path_factory.mktemp("""data""" ) / """file.txt"""
       _UpperCAmelCase							=    FILE_CONTENT
       with open(__snake_case   ,      """w""" ) as f:
              f.write(__snake_case )
       return filename




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Optional[int]:
       import bza

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




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						int:
       import gzip

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




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Optional[int]:
       if datasets.config.LZ4_AVAILABLE:
              import lza.frame

              _UpperCAmelCase							=    tmp_path_factory.mktemp("""data""" ) / """file.txt.lz4"""
              _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						List[Any]:
       if datasets.config.PY7ZR_AVAILABLE:
              import pyazr

              _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						Tuple:
       import tarfile

       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Union[str, Any]:
       import lzma

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




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						Dict:
       import zipfile

       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Tuple:
       if datasets.config.ZSTANDARD_AVAILABLE:
              import zstandard as zstd

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




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						str:
       _UpperCAmelCase							=    tmp_path_factory.mktemp("""data""" ) / """file.xml"""
       _UpperCAmelCase							=    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(__snake_case   ,      """w""" ) as f:
              f.write(__snake_case )
       return filename


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

__a:     int   					=					[
    {'''col_3''': 0.0, '''col_1''': '''0''', '''col_2''': 0},
    {'''col_3''': 1.0, '''col_1''': '''1''', '''col_2''': 1},
]

__a:     Tuple   					=					[
    {'''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       _SCREAMING_SNAKE_CASE (							)				->						Optional[Any]:
       return DATA_DICT_OF_LISTS




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						str:
       _UpperCAmelCase							=    datasets.Dataset.from_dict(__snake_case )
       _UpperCAmelCase							=    str(tmp_path_factory.mktemp("""data""" ) / """dataset.arrow""" )
       dataset.map(cache_file_name=__snake_case )
       return path




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Optional[int]:
       _UpperCAmelCase							=    str(tmp_path_factory.mktemp("""data""" ) / """dataset.sqlite""" )
       with contextlib.closing(sqlitea.connect(__snake_case ) ) 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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						str:
       _UpperCAmelCase							=    str(tmp_path_factory.mktemp("""data""" ) / """dataset.csv""" )
       with open(__snake_case   ,      """w"""   ,      newline="""""" ) as f:
              _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Tuple:
       _UpperCAmelCase							=    str(tmp_path_factory.mktemp("""data""" ) / """dataset2.csv""" )
       with open(__snake_case   ,      """w"""   ,      newline="""""" ) as f:
              _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						Tuple:
       import bza

       _UpperCAmelCase							=    tmp_path_factory.mktemp("""data""" ) / """dataset.csv.bz2"""
       with open(__snake_case   ,      """rb""" ) as f:
              _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						List[Any]:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						Optional[Any]:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						int:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Union[str, Any]:
       _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(__snake_case   ,      """wb""" ) as f:
              _UpperCAmelCase							=    pq.ParquetWriter(__snake_case   ,      schema=__snake_case )
              _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Dict:
       _UpperCAmelCase							=    str(tmp_path_factory.mktemp("""data""" ) / """dataset.json""" )
       _UpperCAmelCase							=    {"""data""": DATA}
       with open(__snake_case   ,      """w""" ) as f:
              json.dump(__snake_case   ,      __snake_case )
       return path




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Dict:
       _UpperCAmelCase							=    str(tmp_path_factory.mktemp("""data""" ) / """dataset.json""" )
       _UpperCAmelCase							=    {"""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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Tuple:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Any:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Union[str, Any]:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Dict:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						str:
       import gzip

       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						str:
       import gzip

       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						Dict:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case   ,      __snake_case )				->						Tuple:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						Union[str, Any]:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						int:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case   ,      __snake_case )				->						int:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Union[str, Any]:
       _UpperCAmelCase							=    ["""0""", """1""", """2""", """3"""]
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Union[str, Any]:
       _UpperCAmelCase							=    ["""0""", """1""", """2""", """3"""]
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						str:
       _UpperCAmelCase							=    ["""0""", """1""", """2""", """3"""]
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						Optional[Any]:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						Any:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case )				->						str:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						str:
       _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(__snake_case   ,      """w"""   ,      encoding="""utf-8""" ) as f:
              f.write(__snake_case )
       return path




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							)				->						Union[str, Any]:
       return os.path.join("""tests"""   ,      """features"""   ,      """data"""   ,      """test_image_rgb.jpg""" )




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




@pytest.fixture(scope="""session""" )
def       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						Optional[Any]:
       _UpperCAmelCase							=    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       _SCREAMING_SNAKE_CASE (							__snake_case )				->						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""" * 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







import os
import sys

__a:     Union[str, Any]   					=					os.path.join(os.path.dirname(__file__), '''src''')
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


__a:     Union[str, Any]   					=					[
    '''torch''',
    '''numpy''',
    '''tokenizers''',
    '''filelock''',
    '''requests''',
    '''tqdm''',
    '''regex''',
    '''sentencepiece''',
    '''sacremoses''',
    '''importlib_metadata''',
    '''huggingface_hub''',
]




@add_start_docstrings(AutoConfig.__doc__ )
def       _SCREAMING_SNAKE_CASE (							*__snake_case   ,      **__snake_case )				->						Union[str, Any]:
       return AutoConfig.from_pretrained(*__snake_case   ,      **__snake_case )




@add_start_docstrings(AutoTokenizer.__doc__ )
def       _SCREAMING_SNAKE_CASE (							*__snake_case   ,      **__snake_case )				->						Any:
       return AutoTokenizer.from_pretrained(*__snake_case   ,      **__snake_case )




@add_start_docstrings(AutoModel.__doc__ )
def       _SCREAMING_SNAKE_CASE (							*__snake_case   ,      **__snake_case )				->						Tuple:
       return AutoModel.from_pretrained(*__snake_case   ,      **__snake_case )




@add_start_docstrings(AutoModelForCausalLM.__doc__ )
def       _SCREAMING_SNAKE_CASE (							*__snake_case   ,      **__snake_case )				->						Tuple:
       return AutoModelForCausalLM.from_pretrained(*__snake_case   ,      **__snake_case )




@add_start_docstrings(AutoModelForMaskedLM.__doc__ )
def       _SCREAMING_SNAKE_CASE (							*__snake_case   ,      **__snake_case )				->						Optional[Any]:
       return AutoModelForMaskedLM.from_pretrained(*__snake_case   ,      **__snake_case )




@add_start_docstrings(AutoModelForSequenceClassification.__doc__ )
def       _SCREAMING_SNAKE_CASE (							*__snake_case   ,      **__snake_case )				->						List[str]:
       return AutoModelForSequenceClassification.from_pretrained(*__snake_case   ,      **__snake_case )





@add_start_docstrings(AutoModelForQuestionAnswering.__doc__ )
def       _SCREAMING_SNAKE_CASE (							*__snake_case   ,      **__snake_case )				->						List[Any]:
       return AutoModelForQuestionAnswering.from_pretrained(*__snake_case   ,      **__snake_case )