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


# FILE_CONTENT + files


__lowerCamelCase							=       """\
    Text data.
    Second line of data."""


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : Any    ):
       snake_case       :   Any							=      tmp_path_factory.mktemp("data"    ) / "file.txt"
       snake_case       :   Union[str, Any]							=      FILE_CONTENT
       with open(__lowerCamelCase				,					"w"    ) as f:
              f.write(__lowerCamelCase    )
       return filename


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : Dict    ):
       import bza

       snake_case       :   Tuple							=      tmp_path_factory.mktemp("data"    ) / "file.txt.bz2"
       snake_case       :   List[Any]							=      bytes(__lowerCamelCase				,					"utf-8"    )
       with bza.open(__lowerCamelCase				,					"wb"    ) as f:
              f.write(__lowerCamelCase    )
       return path


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : Tuple    ):
       import gzip

       snake_case       :   Union[str, Any]							=      str(tmp_path_factory.mktemp("data"    ) / "file.txt.gz"    )
       snake_case       :   Any							=      bytes(__lowerCamelCase				,					"utf-8"    )
       with gzip.open(__lowerCamelCase				,					"wb"    ) as f:
              f.write(__lowerCamelCase    )
       return path


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : Union[str, Any]    ):
       if datasets.config.LZ4_AVAILABLE:
              import lza.frame

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


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : Union[str, Any]				,					__lowerCamelCase     : List[str]    ):
       if datasets.config.PY7ZR_AVAILABLE:
              import pyazr

              snake_case       :   Dict							=      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 			UpperCamelCase					(    __lowerCamelCase     : int				,					__lowerCamelCase     : Union[str, Any]    ):
       import tarfile

       snake_case       :   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 			UpperCamelCase					(    __lowerCamelCase     : Any    ):
       import lzma

       snake_case       :   Optional[int]							=      tmp_path_factory.mktemp("data"    ) / "file.txt.xz"
       snake_case       :   int							=      bytes(__lowerCamelCase				,					"utf-8"    )
       with lzma.open(__lowerCamelCase				,					"wb"    ) as f:
              f.write(__lowerCamelCase    )
       return path


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : List[Any]				,					__lowerCamelCase     : Any    ):
       import zipfile

       snake_case       :   List[Any]							=      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 			UpperCamelCase					(    __lowerCamelCase     : Union[str, Any]    ):
       if datasets.config.ZSTANDARD_AVAILABLE:
              import zstandard as zstd

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


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : Tuple    ):
       snake_case       :   Optional[Any]							=      tmp_path_factory.mktemp("data"    ) / "file.xml"
       snake_case       :   str							=      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							=       [
    {"""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							=       [
    {"""col_1""": """4""", """col_2""": 4, """col_3""": 4.0},
    {"""col_1""": """5""", """col_2""": 5, """col_3""": 5.0},
]
__lowerCamelCase							=       {
    """col_1""": ["""0""", """1""", """2""", """3"""],
    """col_2""": [0, 1, 2, 3],
    """col_3""": [0.0, 1.0, 2.0, 3.0],
}

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

__lowerCamelCase							=       [
    {"""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 			UpperCamelCase					(    ):
       return DATA_DICT_OF_LISTS


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : Union[str, Any]    ):
       snake_case       :   str							=      datasets.Dataset.from_dict(__lowerCamelCase    )
       snake_case       :   Optional[int]							=      str(tmp_path_factory.mktemp("data"    ) / "dataset.arrow"    )
       dataset.map(cache_file_name=__lowerCamelCase    )
       return path


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

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


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


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : str    ):
       snake_case       :   List[str]							=      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 			UpperCamelCase					(    __lowerCamelCase     : Any    ):
       snake_case       :   List[str]							=      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 			UpperCamelCase					(    __lowerCamelCase     : Any    ):
       snake_case       :   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 			UpperCamelCase					(    __lowerCamelCase     : Any    ):
       snake_case       :   str							=      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 			UpperCamelCase					(    __lowerCamelCase     : Dict				,					__lowerCamelCase     : List[str]    ):
       import gzip

       snake_case       :   Tuple							=      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 			UpperCamelCase					(    __lowerCamelCase     : Union[str, Any]				,					__lowerCamelCase     : List[str]    ):
       import gzip

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


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


@pytest.fixture(scope="session"    )
def 			UpperCamelCase					(    __lowerCamelCase     : Tuple				,					__lowerCamelCase     : List[str]    ):
       snake_case       :   str							=      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 			UpperCamelCase					(    __lowerCamelCase     : List[str]    ):
       snake_case       :   Optional[Any]							=      tmp_path_factory.mktemp("data_dir"    )

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

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

       return data_dir







from __future__ import annotations

__lowerCamelCase							=       list[list[int]]

# assigning initial values to the grid
__lowerCamelCase							=       [
    [3, 0, 6, 5, 0, 8, 4, 0, 0],
    [5, 2, 0, 0, 0, 0, 0, 0, 0],
    [0, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]

# a grid with no solution
__lowerCamelCase							=       [
    [5, 0, 6, 5, 0, 8, 4, 0, 3],
    [5, 2, 0, 0, 0, 0, 0, 0, 2],
    [1, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]


def 			UpperCamelCase					(    __lowerCamelCase     : Matrix				,					__lowerCamelCase     : int				,					__lowerCamelCase     : int				,					__lowerCamelCase     : int    ):
       for i in range(9    ):
              if grid[row][i] == n or grid[i][column] == n:
                     return False

       for i in range(3    ):
              for j in range(3    ):
                     if grid[(row - row % 3) + i][(column - column % 3) + j] == n:
                            return False

       return True


def 			UpperCamelCase					(    __lowerCamelCase     : Matrix    ):
       for i in range(9    ):
              for j in range(9    ):
                     if grid[i][j] == 0:
                            return i, j
       return None


def 			UpperCamelCase					(    __lowerCamelCase     : Matrix    ):
       if location := find_empty_location(__lowerCamelCase    ):
              snake_case				,					snake_case       :   Union[str, Any]							=      location
       else:
              # If the location is ``None``, then the grid is solved.
              return grid

       for digit in range(1				,					10    ):
              if is_safe(__lowerCamelCase				,					__lowerCamelCase				,					__lowerCamelCase				,					__lowerCamelCase    ):
                     snake_case       :   List[Any]							=      digit

                     if sudoku(__lowerCamelCase    ) is not None:
                            return grid

                     snake_case       :   Union[str, Any]							=      0

       return None


def 			UpperCamelCase					(    __lowerCamelCase     : Matrix    ):
       for row in grid:
              for cell in row:
                     print(__lowerCamelCase				,					end=" "    )
              print()


if __name__ == "__main__":
   # make a copy of grid so that you can compare with the unmodified grid
   for example_grid in (initial_grid, no_solution):
      print("""\nExample grid:\n""" + """=""" * 20)
      print_solution(example_grid)
      print("""\nExample grid solution:""")
      __lowerCamelCase							=       sudoku(example_grid)
      if solution is not None:
         print_solution(solution)
      else:
         print("""Cannot find a solution.""")





