




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




 """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(_lowerCAmelCase	)	),
     }						,							features=_lowerCAmelCase						,							)
 return dataset



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   Optional[Any]						,							_lowerCAmelCase							:   Any	):




 """simple docstring"""







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


# FILE_CONTENT + files


_lowerCAmelCase						:   Optional[Any]		=   "\\n    Text data.\n    Second line of data."



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   str	):




 """simple docstring"""







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



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




 """simple docstring"""







 import bza

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



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




 """simple docstring"""







 import gzip

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



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   Any	):




 """simple docstring"""







 if datasets.config.LZ4_AVAILABLE:
  import lza.frame

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



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   List[str]						,							_lowerCAmelCase							:   Tuple	):




 """simple docstring"""







 if datasets.config.PY7ZR_AVAILABLE:
  import pyazr

  UpperCAmelCase__							 =						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							:   int						,							_lowerCAmelCase							:   Dict	):




 """simple docstring"""







 import tarfile

 UpperCAmelCase__							 =						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							:   List[Any]	):




 """simple docstring"""







 import lzma

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



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   Dict						,							_lowerCAmelCase							:   str	):




 """simple docstring"""







 import zipfile

 UpperCAmelCase__							 =						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							:   Optional[int]	):




 """simple docstring"""







 if datasets.config.ZSTANDARD_AVAILABLE:
  import zstandard as zstd

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



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   Dict	):




 """simple docstring"""







 UpperCAmelCase__							 =						tmp_path_factory.mktemp("data"	) / "file.xml"
 UpperCAmelCase__							 =						textwrap.dedent(
     "\\n    <?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n    <tmx version=\"1.4\">\n      <header segtype=\"sentence\" srclang=\"ca\" />\n      <body>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 1</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 1</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 2</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 2</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 3</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 3</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 4</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 4</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 5</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 5</seg></tuv>\n        </tu>\n      </body>\n    </tmx>"	)
 with open(_lowerCAmelCase						,							"w"	) as f:
  f.write(_lowerCAmelCase	)
 return filename


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

_lowerCAmelCase						:   int		=   [
    {"col_3": 0.0, "col_1": "0", "col_2": 0},
    {"col_3": 1.0, "col_1": "1", "col_2": 1},
]

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




 """simple docstring"""







 return DATA_DICT_OF_LISTS



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




 """simple docstring"""







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



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   str	):




 """simple docstring"""







 UpperCAmelCase__							 =						str(tmp_path_factory.mktemp("data"	) / "dataset.sqlite"	)
 with contextlib.closing(sqlitea.connect(_lowerCAmelCase	)	) 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 						lowerCAmelCase		(		_lowerCAmelCase							:   Union[str, Any]	):




 """simple docstring"""







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




 """simple docstring"""







 UpperCAmelCase__							 =						str(tmp_path_factory.mktemp("data"	) / "dataset2.csv"	)
 with open(_lowerCAmelCase						,							"w"						,							newline=""	) as f:
  UpperCAmelCase__							 =						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							:   Any						,							_lowerCAmelCase							:   Tuple	):




 """simple docstring"""







 import bza

 UpperCAmelCase__							 =						tmp_path_factory.mktemp("data"	) / "dataset.csv.bz2"
 with open(_lowerCAmelCase						,							"rb"	) as f:
  UpperCAmelCase__							 =						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							:   str						,							_lowerCAmelCase							:   Tuple						,							_lowerCAmelCase							:   List[Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Any						,							_lowerCAmelCase							:   int						,							_lowerCAmelCase							:   List[Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   str						,							_lowerCAmelCase							:   int						,							_lowerCAmelCase							:   Tuple	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Union[str, Any]	):




 """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(_lowerCAmelCase						,							"wb"	) as f:
  UpperCAmelCase__							 =						pq.ParquetWriter(_lowerCAmelCase						,							schema=_lowerCAmelCase	)
  UpperCAmelCase__							 =						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							:   str	):




 """simple docstring"""







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



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   int	):




 """simple docstring"""







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



@pytest.fixture(scope="session"	)
def 						lowerCAmelCase		(		_lowerCAmelCase							:   Tuple	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Dict	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Tuple	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Tuple	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   List[str]						,							_lowerCAmelCase							:   str	):




 """simple docstring"""







 import gzip

 UpperCAmelCase__							 =						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							:   Any						,							_lowerCAmelCase							:   Tuple	):




 """simple docstring"""







 import gzip

 UpperCAmelCase__							 =						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							:   List[str]						,							_lowerCAmelCase							:   str						,							_lowerCAmelCase							:   Any	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   str						,							_lowerCAmelCase							:   str						,							_lowerCAmelCase							:   Union[str, Any]						,							_lowerCAmelCase							:   Dict	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   List[str]						,							_lowerCAmelCase							:   int						,							_lowerCAmelCase							:   str	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Dict						,							_lowerCAmelCase							:   List[Any]						,							_lowerCAmelCase							:   List[Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Dict						,							_lowerCAmelCase							:   List[str]						,							_lowerCAmelCase							:   Any						,							_lowerCAmelCase							:   List[Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   str	):




 """simple docstring"""







 UpperCAmelCase__							 =						["0", "1", "2", "3"]
 UpperCAmelCase__							 =						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							:   Optional[Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						["0", "1", "2", "3"]
 UpperCAmelCase__							 =						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							:   Optional[Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						["0", "1", "2", "3"]
 UpperCAmelCase__							 =						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							:   List[str]						,							_lowerCAmelCase							:   Optional[int]						,							_lowerCAmelCase							:   Optional[Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Optional[Any]						,							_lowerCAmelCase							:   List[Any]						,							_lowerCAmelCase							:   Tuple	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   List[Any]						,							_lowerCAmelCase							:   Optional[int]						,							_lowerCAmelCase							:   List[Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   List[Any]	):




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



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




 """simple docstring"""







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



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




 """simple docstring"""







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



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




 """simple docstring"""







 UpperCAmelCase__							 =						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							:   Optional[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 random
import unittest

import torch

from diffusers import IFInpaintingSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin
@skip_mps
class 			_UpperCamelCase      (				lowerCAmelCase	,       lowerCAmelCase	,       unittest.TestCase		):
      UpperCAmelCase_        =		IFInpaintingSuperResolutionPipeline
      UpperCAmelCase_        =		TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""width""", """height"""}
      UpperCAmelCase_        =		TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"""original_image"""}		)
      UpperCAmelCase_        =		PipelineTesterMixin.required_optional_params - {"""latents"""}
      def 	UpperCAmelCase_						(			self   :str      )     ->			Optional[Any]:
       return self._get_superresolution_dummy_components()
      def 	UpperCAmelCase_						(			self   :List[str] ,      lowerCamelCase   :Dict ,      lowerCamelCase   :Optional[Any]=0      )     ->			int:
       if str(lowerCamelCase      ).startswith("mps"      ):
        UpperCAmelCase__							 =						torch.manual_seed(lowerCamelCase      )
       else:
        UpperCAmelCase__							 =						torch.Generator(device=lowerCamelCase      ).manual_seed(lowerCamelCase      )

       UpperCAmelCase__							 =						floats_tensor((1, 3, 16, 16) ,      rng=random.Random(lowerCamelCase      )      ).to(lowerCamelCase      )
       UpperCAmelCase__							 =						floats_tensor((1, 3, 32, 32) ,      rng=random.Random(lowerCamelCase      )      ).to(lowerCamelCase      )
       UpperCAmelCase__							 =						floats_tensor((1, 3, 32, 32) ,      rng=random.Random(lowerCamelCase      )      ).to(lowerCamelCase      )

       UpperCAmelCase__							 =						{
           "prompt": "A painting of a squirrel eating a burger",
           "image": image,
           "original_image": original_image,
           "mask_image": mask_image,
           "generator": generator,
           "num_inference_steps": 2,
           "output_type": "numpy",
       }

       return inputs
      @unittest.skipIf(
          torch_device != "cuda" or not is_xformers_available() ,      reason="XFormers attention is only available with CUDA and `xformers` installed" ,      )
      def 	UpperCAmelCase_						(			self   :Union[str, Any]      )     ->			Dict:
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3      )
      def 	UpperCAmelCase_						(			self   :List[str]      )     ->			Dict:
       self._test_save_load_optional_components()
      @unittest.skipIf(torch_device != "cuda" ,      reason="float16 requires CUDA"      )
      def 	UpperCAmelCase_						(			self   :Tuple      )     ->			Dict:
       # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
       super().test_save_load_floataa(expected_max_diff=1e-1      )
      def 	UpperCAmelCase_						(			self   :Dict      )     ->			str:
       self._test_attention_slicing_forward_pass(expected_max_diff=1e-2      )
      def 	UpperCAmelCase_						(			self   :Dict      )     ->			str:
       self._test_save_load_local()







      def 	UpperCAmelCase_						(			self   :List[str]      )     ->			List[str]:
       self._test_inference_batch_single_identical(
           expected_max_diff=1e-2 ,      )





