





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 _a				(	)	->						List[str]:







      '''simple docstring'''






      __A          =				10
      __A          =				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''' ),
          } )
      __A          =				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 _a				(	lowerCamelCase:   str					,				lowerCamelCase:   Tuple )	->						Tuple:







      '''simple docstring'''






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


# FILE_CONTENT + files


snake_case__					:							Dict													=     '\\n    Text data.\n    Second line of data.'



@pytest.fixture(scope='''session''' )
def _a				(	lowerCamelCase:   str )	->						Any:







      '''simple docstring'''






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



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







      '''simple docstring'''






      import bza

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



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







      '''simple docstring'''






      import gzip

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



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







      '''simple docstring'''






      if datasets.config.LZ4_AVAILABLE:
            import lza.frame

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



@pytest.fixture(scope='''session''' )
def _a				(	lowerCamelCase:   Optional[Any]					,				lowerCamelCase:   List[Any] )	->						int:







      '''simple docstring'''






      if datasets.config.PY7ZR_AVAILABLE:
            import pyazr

            __A          =				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 _a				(	lowerCamelCase:   List[Any]					,				lowerCamelCase:   Any )	->						Optional[int]:







      '''simple docstring'''






      import tarfile

      __A          =				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 _a				(	lowerCamelCase:   int )	->						List[str]:







      '''simple docstring'''






      import lzma

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



@pytest.fixture(scope='''session''' )
def _a				(	lowerCamelCase:   List[Any]					,				lowerCamelCase:   Optional[int] )	->						List[Any]:







      '''simple docstring'''






      import zipfile

      __A          =				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 _a				(	lowerCamelCase:   Union[str, Any] )	->						Optional[int]:







      '''simple docstring'''






      if datasets.config.ZSTANDARD_AVAILABLE:
            import zstandard as zstd

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



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







      '''simple docstring'''






      __A          =				tmp_path_factory.mktemp('''data''' ) / '''file.xml'''
      __A          =				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(lowerCamelCase					,				'''w''' ) as f:
            f.write(lowerCamelCase )
      return filename


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

snake_case__					:							Union[str, Any]													=     [
    {'col_3': 0.0, 'col_1': '0', 'col_2': 0},
    {'col_3': 1.0, 'col_1': '1', 'col_2': 1},
]

snake_case__					:							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 _a				(	)	->						Dict:







      '''simple docstring'''






      return DATA_DICT_OF_LISTS



@pytest.fixture(scope='''session''' )
def _a				(	lowerCamelCase:   List[Any] )	->						Any:







      '''simple docstring'''






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



@pytest.fixture(scope='''session''' )
def _a				(	lowerCamelCase:   Optional[Any] )	->						str:







      '''simple docstring'''






      __A          =				str(tmp_path_factory.mktemp('''data''' ) / '''dataset.sqlite''' )
      with contextlib.closing(sqlitea.connect(lowerCamelCase ) ) as con:
            __A          =				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 _a				(	lowerCamelCase:   int )	->						Optional[Any]:







      '''simple docstring'''






      __A          =				str(tmp_path_factory.mktemp('''data''' ) / '''dataset.csv''' )
      with open(lowerCamelCase					,				'''w'''					,				newline='''''' ) as f:
            __A          =				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 _a				(	lowerCamelCase:   Tuple )	->						Tuple:







      '''simple docstring'''






      __A          =				str(tmp_path_factory.mktemp('''data''' ) / '''dataset2.csv''' )
      with open(lowerCamelCase					,				'''w'''					,				newline='''''' ) as f:
            __A          =				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 _a				(	lowerCamelCase:   Union[str, Any]					,				lowerCamelCase:   Union[str, Any] )	->						Tuple:







      '''simple docstring'''






      import bza

      __A          =				tmp_path_factory.mktemp('''data''' ) / '''dataset.csv.bz2'''
      with open(lowerCamelCase					,				'''rb''' ) as f:
            __A          =				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 _a				(	lowerCamelCase:   List[str]					,				lowerCamelCase:   Optional[int]					,				lowerCamelCase:   Tuple )	->						Optional[int]:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   List[str]					,				lowerCamelCase:   Any					,				lowerCamelCase:   int )	->						int:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Optional[Any]					,				lowerCamelCase:   List[Any]					,				lowerCamelCase:   Optional[Any] )	->						Any:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   str )	->						Optional[int]:







      '''simple docstring'''






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







      '''simple docstring'''






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



@pytest.fixture(scope='''session''' )
def _a				(	lowerCamelCase:   Tuple )	->						Tuple:







      '''simple docstring'''






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



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







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   List[Any] )	->						Union[str, Any]:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Optional[int] )	->						Tuple:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Dict )	->						int:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Optional[Any]					,				lowerCamelCase:   Union[str, Any] )	->						Optional[Any]:







      '''simple docstring'''






      import gzip

      __A          =				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 _a				(	lowerCamelCase:   List[Any]					,				lowerCamelCase:   Any )	->						int:







      '''simple docstring'''






      import gzip

      __A          =				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 _a				(	lowerCamelCase:   List[Any]					,				lowerCamelCase:   int					,				lowerCamelCase:   int )	->						List[Any]:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   int					,				lowerCamelCase:   List[str]					,				lowerCamelCase:   Dict					,				lowerCamelCase:   Union[str, Any] )	->						Optional[int]:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Tuple					,				lowerCamelCase:   List[str]					,				lowerCamelCase:   Any )	->						Any:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Dict					,				lowerCamelCase:   List[Any]					,				lowerCamelCase:   List[str] )	->						Tuple:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Optional[int]					,				lowerCamelCase:   Optional[Any]					,				lowerCamelCase:   Tuple					,				lowerCamelCase:   List[Any] )	->						Union[str, Any]:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Union[str, Any] )	->						Union[str, Any]:







      '''simple docstring'''






      __A          =				['''0''', '''1''', '''2''', '''3''']
      __A          =				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 _a				(	lowerCamelCase:   Dict )	->						Union[str, Any]:







      '''simple docstring'''






      __A          =				['''0''', '''1''', '''2''', '''3''']
      __A          =				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 _a				(	lowerCamelCase:   Tuple )	->						Optional[Any]:







      '''simple docstring'''






      __A          =				['''0''', '''1''', '''2''', '''3''']
      __A          =				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 _a				(	lowerCamelCase:   List[str]					,				lowerCamelCase:   List[str]					,				lowerCamelCase:   Any )	->						Any:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   List[Any]					,				lowerCamelCase:   Any					,				lowerCamelCase:   Tuple )	->						Any:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Optional[int]					,				lowerCamelCase:   List[Any]					,				lowerCamelCase:   Optional[int] )	->						Any:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Union[str, Any] )	->						Union[str, Any]:







      '''simple docstring'''






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







      '''simple docstring'''






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



@pytest.fixture(scope='''session''' )
def _a				(	)	->						Dict:







      '''simple docstring'''






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



@pytest.fixture(scope='''session''' )
def _a				(	lowerCamelCase:   int					,				lowerCamelCase:   Tuple )	->						Any:







      '''simple docstring'''






      __A          =				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 _a				(	lowerCamelCase:   Any )	->						Union[str, Any]:







      '''simple docstring'''






      __A          =				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












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case__					:							Optional[Any]													=     {'configuration_ibert': ['IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'IBertConfig', 'IBertOnnxConfig']}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       snake_case__					:							List[str]													=     [
           'IBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'IBertForMaskedLM',
           'IBertForMultipleChoice',
           'IBertForQuestionAnswering',
           'IBertForSequenceClassification',
           'IBertForTokenClassification',
           'IBertModel',
           'IBertPreTrainedModel',
       ]

if TYPE_CHECKING:
       from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_ibert import (
                  IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  IBertForMaskedLM,
                  IBertForMultipleChoice,
                  IBertForQuestionAnswering,
                  IBertForSequenceClassification,
                  IBertForTokenClassification,
                  IBertModel,
                  IBertPreTrainedModel,
              )

else:
       import sys

       snake_case__					:							Dict													=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





