




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_ (						):
				__magic_name__						:						Dict										=10
				__magic_name__						:						str										=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""" ),
				    } )
				__magic_name__						:						Any										=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_ (						lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Optional[int]										=str(tmp_path_factory.mktemp("""data""" ) / """file.arrow""" )
				dataset.map(cache_file_name=lowerCamelCase )
				return filename


# FILE_CONTENT + files


UpperCAmelCase_		:					str          =  "\\n    Text data.\n    Second line of data."




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						Optional[Any]										=tmp_path_factory.mktemp("""data""" ) / """file.txt"""
				__magic_name__						:						List[str]										=FILE_CONTENT
				with open(lowerCamelCase						,  """w""" ) as f:
								f.write(lowerCamelCase )
				return filename




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				import bza

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




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				import gzip

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




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				if datasets.config.LZ4_AVAILABLE:
								import lza.frame

								__magic_name__						:						Dict										=tmp_path_factory.mktemp("""data""" ) / """file.txt.lz4"""
								__magic_name__						:						List[Any]										=bytes(lowerCamelCase						,  """utf-8""" )
								with lza.frame.open(lowerCamelCase						,  """wb""" ) as f:
												f.write(lowerCamelCase )
								return path




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				if datasets.config.PY7ZR_AVAILABLE:
								import pyazr

								__magic_name__						:						List[Any]										=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_ (						lowerCamelCase						,  lowerCamelCase ):
				import tarfile

				__magic_name__						:						Optional[int]										=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_ (						lowerCamelCase ):
				import lzma

				__magic_name__						:						Union[str, Any]										=tmp_path_factory.mktemp("""data""" ) / """file.txt.xz"""
				__magic_name__						:						Dict										=bytes(lowerCamelCase						,  """utf-8""" )
				with lzma.open(lowerCamelCase						,  """wb""" ) as f:
								f.write(lowerCamelCase )
				return path




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				import zipfile

				__magic_name__						:						str										=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_ (						lowerCamelCase ):
				if datasets.config.ZSTANDARD_AVAILABLE:
								import zstandard as zstd

								__magic_name__						:						Optional[int]										=tmp_path_factory.mktemp("""data""" ) / """file.txt.zst"""
								__magic_name__						:						int										=bytes(lowerCamelCase						,  """utf-8""" )
								with zstd.open(lowerCamelCase						,  """wb""" ) as f:
												f.write(lowerCamelCase )
								return path




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						Optional[int]										=tmp_path_factory.mktemp("""data""" ) / """file.xml"""
				__magic_name__						:						Union[str, Any]										=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


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

UpperCAmelCase_		:					Any          =  [
    {"col_3": 0.0, "col_1": "0", "col_2": 0},
    {"col_3": 1.0, "col_1": "1", "col_2": 1},
]

UpperCAmelCase_		:					List[Any]          =  [
    {"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_ (						):
				return DATA_DICT_OF_LISTS




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						str										=datasets.Dataset.from_dict(lowerCamelCase )
				__magic_name__						:						Optional[int]										=str(tmp_path_factory.mktemp("""data""" ) / """dataset.arrow""" )
				dataset.map(cache_file_name=lowerCamelCase )
				return path




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						List[str]										=str(tmp_path_factory.mktemp("""data""" ) / """dataset.sqlite""" )
				with contextlib.closing(sqlitea.connect(lowerCamelCase ) ) as con:
								__magic_name__						:						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 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						Optional[int]										=str(tmp_path_factory.mktemp("""data""" ) / """dataset.csv""" )
				with open(lowerCamelCase						,  """w"""						,  newline="""""" ) as f:
								__magic_name__						:						Union[str, Any]										=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_ (						lowerCamelCase ):
				__magic_name__						:						Optional[Any]										=str(tmp_path_factory.mktemp("""data""" ) / """dataset2.csv""" )
				with open(lowerCamelCase						,  """w"""						,  newline="""""" ) as f:
								__magic_name__						:						Optional[Any]										=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_ (						lowerCamelCase						,  lowerCamelCase ):
				import bza

				__magic_name__						:						Optional[int]										=tmp_path_factory.mktemp("""data""" ) / """dataset.csv.bz2"""
				with open(lowerCamelCase						,  """rb""" ) as f:
								__magic_name__						:						List[Any]										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Tuple										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						List[str]										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						List[str]										=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_ (						lowerCamelCase ):
				__magic_name__						:						Any										=str(tmp_path_factory.mktemp("""data""" ) / """dataset.parquet""" )
				__magic_name__						:						Optional[int]										=pa.schema(
				    {
				        """col_1""": pa.string(),
				        """col_2""": pa.intaa(),
				        """col_3""": pa.floataa(),
				    } )
				with open(lowerCamelCase						,  """wb""" ) as f:
								__magic_name__						:						str										=pq.ParquetWriter(lowerCamelCase						,  schema=lowerCamelCase )
								__magic_name__						:						Optional[int]										=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_ (						lowerCamelCase ):
				__magic_name__						:						Any										=str(tmp_path_factory.mktemp("""data""" ) / """dataset.json""" )
				__magic_name__						:						Optional[Any]										={"""data""": DATA}
				with open(lowerCamelCase						,  """w""" ) as f:
								json.dump(lowerCamelCase						,  lowerCamelCase )
				return path




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						Optional[int]										=str(tmp_path_factory.mktemp("""data""" ) / """dataset.json""" )
				__magic_name__						:						int										={"""data""": DATA_DICT_OF_LISTS}
				with open(lowerCamelCase						,  """w""" ) as f:
								json.dump(lowerCamelCase						,  lowerCamelCase )
				return path




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						Any										=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_ (						lowerCamelCase ):
				__magic_name__						:						int										=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_ (						lowerCamelCase ):
				__magic_name__						:						Tuple										=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_ (						lowerCamelCase ):
				__magic_name__						:						List[Any]										=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_ (						lowerCamelCase						,  lowerCamelCase ):
				import gzip

				__magic_name__						:						List[str]										=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_ (						lowerCamelCase						,  lowerCamelCase ):
				import gzip

				__magic_name__						:						str										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						List[str]										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Optional[int]										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						List[Any]										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Optional[Any]										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						List[Any]										=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_ (						lowerCamelCase ):
				__magic_name__						:						Tuple										=["""0""", """1""", """2""", """3"""]
				__magic_name__						:						Union[str, Any]										=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_ (						lowerCamelCase ):
				__magic_name__						:						Tuple										=["""0""", """1""", """2""", """3"""]
				__magic_name__						:						Any										=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_ (						lowerCamelCase ):
				__magic_name__						:						List[Any]										=["""0""", """1""", """2""", """3"""]
				__magic_name__						:						Union[str, Any]										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Any										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						str										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						str										=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_ (						lowerCamelCase ):
				__magic_name__						:						Any										="""\n""".join(["""First""", """Second\u2029with Unicode new line""", """Third"""] )
				__magic_name__						:						List[Any]										=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_ (						):
				return os.path.join("""tests"""						,  """features"""						,  """data"""						,  """test_image_rgb.jpg""" )




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




@pytest.fixture(scope="""session""" )
def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Union[str, Any]										=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_ (						lowerCamelCase ):
				__magic_name__						:						Dict										=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 unittest

import numpy as np

from transformers import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING, TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
from transformers.pipelines import AudioClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torchaudio,
    slow,
)

from .test_pipelines_common import ANY


@is_pipeline_test
class       __lowerCAmelCase					(       unittest.TestCase      ):


	'''simple docstring'''





	_A													=				MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
	_A													=				TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING

	def    snake_case__(						self:						Optional[int],					lowerCamelCase_:						Tuple,					lowerCamelCase_:						List[Any],					lowerCamelCase_:						Optional[Any]			):
			lowercase__					:      int      =		AudioClassificationPipeline(model=lowerCamelCase_,					feature_extractor=lowerCamelCase_			)

			# test with a raw waveform
			lowercase__					:      Dict      =		np.zeros((34000,)			)
			lowercase__					:      Optional[int]      =		np.zeros((14000,)			)
			return audio_classifier, [audioa, audio]

	def    snake_case__(						self:						Optional[int],					lowerCamelCase_:						Tuple,					lowerCamelCase_:						str			):
			lowercase__   ,				lowercase__					:      List[str]      =		examples
			lowercase__					:      int      =		audio_classifier(lowerCamelCase_			)
			# by default a model is initialized with num_labels=2
			self.assertEqual(
			    lowerCamelCase_,					[
			        {'score': ANY(lowerCamelCase_			), 'label': ANY(lowerCamelCase_			)},
			        {'score': ANY(lowerCamelCase_			), 'label': ANY(lowerCamelCase_			)},
			    ],					)
			lowercase__					:      List[Any]      =		audio_classifier(lowerCamelCase_,					top_k=1			)
			self.assertEqual(
			    lowerCamelCase_,					[
			        {'score': ANY(lowerCamelCase_			), 'label': ANY(lowerCamelCase_			)},
			    ],					)

			self.run_torchaudio(lowerCamelCase_			)

	@require_torchaudio
	def    snake_case__(						self:						Dict,					lowerCamelCase_:						str			):
			import datasets

			# test with a local file
			lowercase__					:      Optional[Any]      =		datasets.load_dataset('hf-internal-testing/librispeech_asr_dummy',					'clean',					split='validation'			)
			lowercase__					:      int      =		dataset[0]['audio']['array']
			lowercase__					:      Tuple      =		audio_classifier(lowerCamelCase_			)
			self.assertEqual(
			    lowerCamelCase_,					[
			        {'score': ANY(lowerCamelCase_			), 'label': ANY(lowerCamelCase_			)},
			        {'score': ANY(lowerCamelCase_			), 'label': ANY(lowerCamelCase_			)},
			    ],					)

	@require_torch
	def    snake_case__(						self:						Optional[int]			):
			lowercase__					:      List[str]      =		'anton-l/wav2vec2-random-tiny-classifier'

			lowercase__					:      Tuple      =		pipeline('audio-classification',					model=lowerCamelCase_			)

			lowercase__					:      List[str]      =		np.ones((8000,)			)
			lowercase__					:      List[Any]      =		audio_classifier(lowerCamelCase_,					top_k=4			)

			lowercase__					:      List[str]      =		[
			    {'score': 0.0_8_4_2, 'label': 'no'},
			    {'score': 0.0_8_3_8, 'label': 'up'},
			    {'score': 0.0_8_3_7, 'label': 'go'},
			    {'score': 0.0_8_3_4, 'label': 'right'},
			]
			lowercase__					:      Optional[int]      =		[
			    {'score': 0.0_8_4_5, 'label': 'stop'},
			    {'score': 0.0_8_4_4, 'label': 'on'},
			    {'score': 0.0_8_4_1, 'label': 'right'},
			    {'score': 0.0_8_3_4, 'label': 'left'},
			]
			self.assertIn(nested_simplify(lowerCamelCase_,					decimals=4			),					[EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]			)

			lowercase__					:      Tuple      =		{'array': np.ones((8000,)			), 'sampling_rate': audio_classifier.feature_extractor.sampling_rate}
			lowercase__					:      Any      =		audio_classifier(lowerCamelCase_,					top_k=4			)
			self.assertIn(nested_simplify(lowerCamelCase_,					decimals=4			),					[EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]			)

	@require_torch
	@slow
	def    snake_case__(						self:						Optional[int]			):
			import datasets

			lowercase__					:      str      =		'superb/wav2vec2-base-superb-ks'

			lowercase__					:      Optional[int]      =		pipeline('audio-classification',					model=lowerCamelCase_			)
			lowercase__					:      List[Any]      =		datasets.load_dataset('anton-l/superb_dummy',					'ks',					split='test'			)

			lowercase__					:      Optional[Any]      =		np.array(dataset[3]['speech'],					dtype=np.floataa			)
			lowercase__					:      Optional[int]      =		audio_classifier(lowerCamelCase_,					top_k=4			)
			self.assertEqual(
			    nested_simplify(lowerCamelCase_,					decimals=3			),					[
			        {'score': 0.9_8_1, 'label': 'go'},
			        {'score': 0.0_0_7, 'label': 'up'},
			        {'score': 0.0_0_6, 'label': '_unknown_'},
			        {'score': 0.0_0_1, 'label': 'down'},
			    ],					)





	@require_tf
	@unittest.skip('Audio classification is not implemented for TF'			)
	def    snake_case__(						self:						int			):
			pass


