


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 							_lowercase    (		):





			"""simple docstring"""




			UpperCamelCase         =					10
			UpperCamelCase         =					datasets.Features(
			    {
			        """tokens""": datasets.Sequence(datasets.Value("""string"""	)	),
			        """labels""": datasets.Sequence(datasets.ClassLabel(names=["""negative""", """positive"""]	)	),
			        """answers""": datasets.Sequence(
			            {
			                """text""": datasets.Value("""string"""	),
			                """answer_start""": datasets.Value("""int32"""	),
			            }	),
			        """id""": datasets.Value("""int64"""	),
			    }	)
			UpperCamelCase         =					datasets.Dataset.from_dict(
			    {
			        """tokens""": [["""foo"""] * 5] * n,
			        """labels""": [[1] * 5] * n,
			        """answers""": [{"""answer_start""": [97], """text""": ["""1976"""]}] * 10,
			        """id""": list(range(_A	)	),
			    }       ,  features=_A       ,  )
			return dataset






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Union[str, Any]       ,  SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """file.arrow"""	)
			dataset.map(cache_file_name=_A	)
			return filename


# FILE_CONTENT + files


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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Union[str, Any]	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """file.txt"""
			UpperCamelCase         =					FILE_CONTENT
			with open(_A       ,  """w"""	) as f:
						f.write(_A	)
			return filename






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Any	):





			"""simple docstring"""




			import bza

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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[int]	):





			"""simple docstring"""




			import gzip

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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			if datasets.config.LZ4_AVAILABLE:
						import lza.frame

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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		str       ,  SCREAMING_SNAKE_CASE_   :		Optional[int]	):





			"""simple docstring"""




			if datasets.config.PY7ZR_AVAILABLE:
						import pyazr

						UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """file.txt.7z"""
						with pyazr.SevenZipFile(_A       ,  """w"""	) as archive:
									archive.write(_A       ,  arcname=os.path.basename(_A	)	)
						return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Union[str, Any]       ,  SCREAMING_SNAKE_CASE_   :		Dict	):





			"""simple docstring"""




			import tarfile

			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """file.txt.tar"""
			with tarfile.TarFile(_A       ,  """w"""	) as f:
						f.add(_A       ,  arcname=os.path.basename(_A	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Any	):





			"""simple docstring"""




			import lzma

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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[int]       ,  SCREAMING_SNAKE_CASE_   :		Any	):





			"""simple docstring"""




			import zipfile

			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """file.txt.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.basename(_A	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Tuple	):





			"""simple docstring"""




			if datasets.config.ZSTANDARD_AVAILABLE:
						import zstandard as zstd

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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[Any]	):





			"""simple docstring"""




			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(_A       ,  """w"""	) as f:
						f.write(_A	)
			return filename


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

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

__snake_case            =   [
    {'''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 							_lowercase    (		):





			"""simple docstring"""




			return DATA_DICT_OF_LISTS






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		str	):





			"""simple docstring"""




			UpperCamelCase         =					datasets.Dataset.from_dict(_A	)
			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset.arrow"""	)
			dataset.map(cache_file_name=_A	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Tuple	):





			"""simple docstring"""




			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset.sqlite"""	)
			with contextlib.closing(sqlitea.connect(_A	)	) 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 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[Any]	):





			"""simple docstring"""




			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset.csv"""	)
			with open(_A       ,  """w"""       ,  newline=""""""	) as f:
						UpperCamelCase         =					csv.DictWriter(_A       ,  fieldnames=["""col_1""", """col_2""", """col_3"""]	)
						writer.writeheader()
						for item in DATA:
									writer.writerow(_A	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[int]	):





			"""simple docstring"""




			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset2.csv"""	)
			with open(_A       ,  """w"""       ,  newline=""""""	) as f:
						UpperCamelCase         =					csv.DictWriter(_A       ,  fieldnames=["""col_1""", """col_2""", """col_3"""]	)
						writer.writeheader()
						for item in DATA:
									writer.writerow(_A	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[str]       ,  SCREAMING_SNAKE_CASE_   :		Optional[Any]	):





			"""simple docstring"""




			import bza

			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.csv.bz2"""
			with open(_A       ,  """rb"""	) as f:
						UpperCamelCase         =					f.read()
			# data = bytes(FILE_CONTENT, "utf-8")
			with bza.open(_A       ,  """wb"""	) as f:
						f.write(_A	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Dict       ,  SCREAMING_SNAKE_CASE_   :		Optional[Any]       ,  SCREAMING_SNAKE_CASE_   :		Tuple	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.csv.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.basename(_A	)	)
						f.write(_A       ,  arcname=os.path.basename(_A	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Union[str, Any]       ,  SCREAMING_SNAKE_CASE_   :		List[Any]       ,  SCREAMING_SNAKE_CASE_   :		Dict	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.csv.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.basename(csv_path.replace(""".csv"""       ,  """.CSV"""	)	)	)
						f.write(_A       ,  arcname=os.path.basename(csva_path.replace(""".csv"""       ,  """.CSV"""	)	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		str       ,  SCREAMING_SNAKE_CASE_   :		List[Any]       ,  SCREAMING_SNAKE_CASE_   :		Union[str, Any]	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset_with_dir.csv.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.join("""main_dir"""       ,  os.path.basename(_A	)	)	)
						f.write(_A       ,  arcname=os.path.join("""main_dir"""       ,  os.path.basename(_A	)	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Tuple	):





			"""simple docstring"""




			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(_A       ,  """wb"""	) as f:
						UpperCamelCase         =					pq.ParquetWriter(_A       ,  schema=_A	)
						UpperCamelCase         =					pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(_A	)	)] for k in DATA[0]}       ,  schema=_A	)
						writer.write_table(_A	)
						writer.close()
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[str]	):





			"""simple docstring"""




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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Dict	):





			"""simple docstring"""




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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset.jsonl"""	)
			with open(_A       ,  """w"""	) as f:
						for item in DATA:
									f.write(json.dumps(_A	) + """\n"""	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Any	):





			"""simple docstring"""




			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset2.jsonl"""	)
			with open(_A       ,  """w"""	) as f:
						for item in DATA:
									f.write(json.dumps(_A	) + """\n"""	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Dict	):





			"""simple docstring"""




			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset_312.jsonl"""	)
			with open(_A       ,  """w"""	) as f:
						for item in DATA_312:
									f.write(json.dumps(_A	) + """\n"""	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset-str.jsonl"""	)
			with open(_A       ,  """w"""	) as f:
						for item in DATA_STR:
									f.write(json.dumps(_A	) + """\n"""	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int       ,  SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			import gzip

			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset.txt.gz"""	)
			with open(_A       ,  """rb"""	) as orig_file:
						with gzip.open(_A       ,  """wb"""	) as zipped_file:
									zipped_file.writelines(_A	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[Any]       ,  SCREAMING_SNAKE_CASE_   :		List[Any]	):





			"""simple docstring"""




			import gzip

			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset.jsonl.gz"""	)
			with open(_A       ,  """rb"""	) as orig_file:
						with gzip.open(_A       ,  """wb"""	) as zipped_file:
									zipped_file.writelines(_A	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Tuple       ,  SCREAMING_SNAKE_CASE_   :		List[Any]       ,  SCREAMING_SNAKE_CASE_   :		Optional[Any]	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.jsonl.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.basename(_A	)	)
						f.write(_A       ,  arcname=os.path.basename(_A	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int       ,  SCREAMING_SNAKE_CASE_   :		Optional[Any]       ,  SCREAMING_SNAKE_CASE_   :		Dict       ,  SCREAMING_SNAKE_CASE_   :		List[str]	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset_nested.jsonl.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.join("""nested"""       ,  os.path.basename(_A	)	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[int]       ,  SCREAMING_SNAKE_CASE_   :		Dict       ,  SCREAMING_SNAKE_CASE_   :		Any	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset_with_dir.jsonl.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.join("""main_dir"""       ,  os.path.basename(_A	)	)	)
						f.write(_A       ,  arcname=os.path.join("""main_dir"""       ,  os.path.basename(_A	)	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[Any]       ,  SCREAMING_SNAKE_CASE_   :		Dict       ,  SCREAMING_SNAKE_CASE_   :		Optional[int]	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.jsonl.tar"""
			with tarfile.TarFile(_A       ,  """w"""	) as f:
						f.add(_A       ,  arcname=os.path.basename(_A	)	)
						f.add(_A       ,  arcname=os.path.basename(_A	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[int]       ,  SCREAMING_SNAKE_CASE_   :		Optional[int]       ,  SCREAMING_SNAKE_CASE_   :		List[str]       ,  SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset_nested.jsonl.tar"""
			with tarfile.TarFile(_A       ,  """w"""	) as f:
						f.add(_A       ,  arcname=os.path.join("""nested"""       ,  os.path.basename(_A	)	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Any	):





			"""simple docstring"""




			UpperCamelCase         =					["""0""", """1""", """2""", """3"""]
			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset.txt"""	)
			with open(_A       ,  """w"""	) as f:
						for item in data:
									f.write(item + """\n"""	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[str]	):





			"""simple docstring"""




			UpperCamelCase         =					["""0""", """1""", """2""", """3"""]
			UpperCamelCase         =					str(tmp_path_factory.mktemp("""data"""	) / """dataset2.txt"""	)
			with open(_A       ,  """w"""	) as f:
						for item in data:
									f.write(item + """\n"""	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[str]	):





			"""simple docstring"""




			UpperCamelCase         =					["""0""", """1""", """2""", """3"""]
			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.abc"""
			with open(_A       ,  """w"""	) as f:
						for item in data:
									f.write(item + """\n"""	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Tuple       ,  SCREAMING_SNAKE_CASE_   :		Optional[Any]       ,  SCREAMING_SNAKE_CASE_   :		Dict	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.text.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.basename(_A	)	)
						f.write(_A       ,  arcname=os.path.basename(_A	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		str       ,  SCREAMING_SNAKE_CASE_   :		Tuple       ,  SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset_with_dir.text.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.join("""main_dir"""       ,  os.path.basename(_A	)	)	)
						f.write(_A       ,  arcname=os.path.join("""main_dir"""       ,  os.path.basename(_A	)	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[Any]       ,  SCREAMING_SNAKE_CASE_   :		str       ,  SCREAMING_SNAKE_CASE_   :		Dict	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.ext.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.basename("""unsupported.ext"""	)	)
						f.write(_A       ,  arcname=os.path.basename("""unsupported_2.ext"""	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Optional[int]	):





			"""simple docstring"""




			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(_A       ,  """w"""       ,  encoding="""utf-8"""	) as f:
						f.write(_A	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		):





			"""simple docstring"""




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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		):





			"""simple docstring"""




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






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		Any       ,  SCREAMING_SNAKE_CASE_   :		Tuple	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data"""	) / """dataset.img.zip"""
			with zipfile.ZipFile(_A       ,  """w"""	) as f:
						f.write(_A       ,  arcname=os.path.basename(_A	)	)
						f.write(_A       ,  arcname=os.path.basename(_A	).replace(""".jpg"""       ,  """2.jpg"""	)	)
			return path






@pytest.fixture(scope="""session"""	)
def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		List[Any]	):





			"""simple docstring"""




			UpperCamelCase         =					tmp_path_factory.mktemp("""data_dir"""	)

			(data_dir / "subdir").mkdir()
			with open(data_dir / """subdir""" / """train.txt"""       ,  """w"""	) as f:
						f.write("""foo\n""" * 10	)
			with open(data_dir / """subdir""" / """test.txt"""       ,  """w"""	) as f:
						f.write("""bar\n""" * 10	)
			# hidden file
			with open(data_dir / """subdir""" / """.test.txt"""       ,  """w"""	) as f:
						f.write("""bar\n""" * 10	)

			# hidden directory
			(data_dir / ".subdir").mkdir()
			with open(data_dir / """.subdir""" / """train.txt"""       ,  """w"""	) as f:
						f.write("""foo\n""" * 10	)
			with open(data_dir / """.subdir""" / """test.txt"""       ,  """w"""	) as f:
						f.write("""bar\n""" * 10	)

			return data_dir



import math
import unittest






def 							_lowercase    (		SCREAMING_SNAKE_CASE_   :		int	):





			"""simple docstring"""




			assert isinstance(SCREAMING_SNAKE_CASE_       ,  SCREAMING_SNAKE_CASE_	) and (
			    number >= 0
			), "'number' must been an int and positive"

			if 1 < number < 4:
						# 2 and 3 are primes
						return True
			elif number < 2 or number % 2 == 0 or number % 3 == 0:
						# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
						return False

			# All primes number are in format of 6k +/- 1
			for i in range(5       ,  int(math.sqrt(SCREAMING_SNAKE_CASE_	) + 1	)       ,  6	):
						if number % i == 0 or number % (i + 2) == 0:
									return False
			return True




class    UpperCAmelCase					(       unittest.TestCase    ):




			def   lowerCamelCase_					(						self							:		Any						):







						"""simple docstring"""







						self.assertTrue(is_prime(2						)						)
						self.assertTrue(is_prime(3						)						)
						self.assertTrue(is_prime(5						)						)
						self.assertTrue(is_prime(7						)						)
						self.assertTrue(is_prime(1_1						)						)
						self.assertTrue(is_prime(1_3						)						)
						self.assertTrue(is_prime(1_7						)						)
						self.assertTrue(is_prime(1_9						)						)
						self.assertTrue(is_prime(2_3						)						)
						self.assertTrue(is_prime(2_9						)						)





			def   lowerCamelCase_					(						self							:		Dict						):







						"""simple docstring"""







						with self.assertRaises(__magic_name__						):
									is_prime(-1_9						)
						self.assertFalse(
						    is_prime(0						)       ,       """Zero doesn't have any positive factors, primes must have exactly two."""       ,       )
						self.assertFalse(
						    is_prime(1						)       ,       """One only has 1 positive factor, primes must have exactly two."""       ,       )
						self.assertFalse(is_prime(2 * 2						)						)
						self.assertFalse(is_prime(2 * 3						)						)
						self.assertFalse(is_prime(3 * 3						)						)
						self.assertFalse(is_prime(3 * 5						)						)
						self.assertFalse(is_prime(3 * 5 * 7						)						)


if __name__ == "__main__":
			unittest.main()




