




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







"""simple docstring"""





def     __SCREAMING_SNAKE_CASE    ( A_					):
	lowerCAmelCase__      :		Any    							=      int(A_					)
	if decimal in (0, 1):  # Exit cases for the recursion
		return str(A_					)
	lowerCAmelCase__							,lowerCAmelCase__      :		Any    							=      divmod(A_		,	2					)
	return binary_recursive(A_					) + str(A_					)

def     __SCREAMING_SNAKE_CASE    ( A_					):
	lowerCAmelCase__      :		Union[str, Any]    							=      str(A_					).strip()
	if not number:
		raise ValueError('''No input value was provided'''					)
	lowerCAmelCase__      :		Any    							=      '''-''' if number.startswith('''-'''					) else ''''''
	lowerCAmelCase__      :		Dict    							=      number.lstrip('''-'''					)
	if not number.isnumeric():
		raise ValueError('''Input value is not an integer'''					)
	return f'{negative}0b{binary_recursive(int(A_					)					)}'


if __name__ == "__main__":
							from doctest import testmod

							testmod()




