


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    (      ):
     __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(SCREAMING_SNAKE_CASE__    )    ),
         }      ,					features=SCREAMING_SNAKE_CASE__      ,					)
     return dataset

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[Any]      ,					SCREAMING_SNAKE_CASE__      : Tuple    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'file.arrow'    )
     dataset.map(cache_file_name=SCREAMING_SNAKE_CASE__    )
     return filename


# FILE_CONTENT + files


_A			=						'\\n    Text data.\n    Second line of data.'

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : str    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'file.txt'
     __UpperCamelCase   							=FILE_CONTENT
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__    )
     return filename

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple    ):
     import bza

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Any    ):
     import gzip

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

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

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[Any]      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]    ):
     if datasets.config.PY7ZR_AVAILABLE:
          import pyazr

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[str]      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]    ):
     import tarfile

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : str    ):
     import lzma

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Dict      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     import zipfile

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[int]    ):
     if datasets.config.ZSTANDARD_AVAILABLE:
          import zstandard as zstd

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Dict    ):
     __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(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__    )
     return filename


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

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

_A			=						[
    {'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    (      SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     __UpperCamelCase   							=datasets.Dataset.from_dict(SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset.arrow'    )
     dataset.map(cache_file_name=SCREAMING_SNAKE_CASE__    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : int    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset.sqlite'    )
     with contextlib.closing(sqlitea.connect(SCREAMING_SNAKE_CASE__    )    ) 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 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Dict    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset.csv'    )
     with open(SCREAMING_SNAKE_CASE__      ,					'w'      ,					newline=''    ) as f:
          __UpperCamelCase   							=csv.DictWriter(SCREAMING_SNAKE_CASE__      ,					fieldnames=['col_1', 'col_2', 'col_3']    )
          writer.writeheader()
          for item in DATA:
               writer.writerow(SCREAMING_SNAKE_CASE__    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : int    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset2.csv'    )
     with open(SCREAMING_SNAKE_CASE__      ,					'w'      ,					newline=''    ) as f:
          __UpperCamelCase   							=csv.DictWriter(SCREAMING_SNAKE_CASE__      ,					fieldnames=['col_1', 'col_2', 'col_3']    )
          writer.writeheader()
          for item in DATA:
               writer.writerow(SCREAMING_SNAKE_CASE__    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Union[str, Any]      ,					SCREAMING_SNAKE_CASE__      : Tuple    ):
     import bza

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[Any]      ,					SCREAMING_SNAKE_CASE__      : List[Any]      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset.csv.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[Any]      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]      ,					SCREAMING_SNAKE_CASE__      : int    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset.csv.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(csv_path.replace('.csv'      ,					'.CSV'    )    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(csva_path.replace('.csv'      ,					'.CSV'    )    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[str]      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]      ,					SCREAMING_SNAKE_CASE__      : Any    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset_with_dir.csv.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.join('main_dir'      ,					os.path.basename(SCREAMING_SNAKE_CASE__    )    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.join('main_dir'      ,					os.path.basename(SCREAMING_SNAKE_CASE__    )    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[str]    ):
     __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(SCREAMING_SNAKE_CASE__      ,					'wb'    ) as f:
          __UpperCamelCase   							=pq.ParquetWriter(SCREAMING_SNAKE_CASE__      ,					schema=SCREAMING_SNAKE_CASE__    )
          __UpperCamelCase   							=pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(SCREAMING_SNAKE_CASE__    )    )] for k in DATA[0]}      ,					schema=SCREAMING_SNAKE_CASE__    )
          writer.write_table(SCREAMING_SNAKE_CASE__    )
          writer.close()
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset.json'    )
     __UpperCamelCase   							={'data': DATA}
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          json.dump(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )
     return path

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Any    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset.jsonl'    )
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          for item in DATA:
               f.write(json.dumps(SCREAMING_SNAKE_CASE__    ) + '\n'    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : str    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset2.jsonl'    )
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          for item in DATA:
               f.write(json.dumps(SCREAMING_SNAKE_CASE__    ) + '\n'    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[str]    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset_312.jsonl'    )
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          for item in DATA_312:
               f.write(json.dumps(SCREAMING_SNAKE_CASE__    ) + '\n'    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[int]    ):
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset-str.jsonl'    )
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          for item in DATA_STR:
               f.write(json.dumps(SCREAMING_SNAKE_CASE__    ) + '\n'    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple      ,					SCREAMING_SNAKE_CASE__      : List[str]    ):
     import gzip

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[Any]      ,					SCREAMING_SNAKE_CASE__      : Tuple    ):
     import gzip

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

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple      ,					SCREAMING_SNAKE_CASE__      : Any      ,					SCREAMING_SNAKE_CASE__      : List[str]    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset.jsonl.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[str]      ,					SCREAMING_SNAKE_CASE__      : Optional[int]      ,					SCREAMING_SNAKE_CASE__      : Dict      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset_nested.jsonl.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.join('nested'      ,					os.path.basename(SCREAMING_SNAKE_CASE__    )    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : Tuple      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset_with_dir.jsonl.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.join('main_dir'      ,					os.path.basename(SCREAMING_SNAKE_CASE__    )    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.join('main_dir'      ,					os.path.basename(SCREAMING_SNAKE_CASE__    )    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[int]      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]      ,					SCREAMING_SNAKE_CASE__      : str    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset.jsonl.tar'
     with tarfile.TarFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.add(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
          f.add(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple      ,					SCREAMING_SNAKE_CASE__      : List[str]      ,					SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : Tuple    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset_nested.jsonl.tar'
     with tarfile.TarFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.add(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.join('nested'      ,					os.path.basename(SCREAMING_SNAKE_CASE__    )    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[Any]    ):
     __UpperCamelCase   							=['0', '1', '2', '3']
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset.txt'    )
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          for item in data:
               f.write(item + '\n'    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : str    ):
     __UpperCamelCase   							=['0', '1', '2', '3']
     __UpperCamelCase   							=str(tmp_path_factory.mktemp('data'    ) / 'dataset2.txt'    )
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          for item in data:
               f.write(item + '\n'    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple    ):
     __UpperCamelCase   							=['0', '1', '2', '3']
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset.abc'
     with open(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          for item in data:
               f.write(item + '\n'    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Any      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]      ,					SCREAMING_SNAKE_CASE__      : str    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset.text.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : str      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset_with_dir.text.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.join('main_dir'      ,					os.path.basename(SCREAMING_SNAKE_CASE__    )    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.join('main_dir'      ,					os.path.basename(SCREAMING_SNAKE_CASE__    )    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[Any]      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]      ,					SCREAMING_SNAKE_CASE__      : Dict    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset.ext.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename('unsupported.ext'    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename('unsupported_2.ext'    )    )
     return path

@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[int]    ):
     __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(SCREAMING_SNAKE_CASE__      ,					'w'      ,					encoding='utf-8'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__    )
     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    (      SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : str    ):
     __UpperCamelCase   							=tmp_path_factory.mktemp('data'    ) / 'dataset.img.zip'
     with zipfile.ZipFile(SCREAMING_SNAKE_CASE__      ,					'w'    ) as f:
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    )    )
          f.write(SCREAMING_SNAKE_CASE__      ,					arcname=os.path.basename(SCREAMING_SNAKE_CASE__    ).replace('.jpg'      ,					'2.jpg'    )    )
     return path





@pytest.fixture(scope='session'    )
def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple    ):
     __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









from __future__ import annotations

from typing import Any

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : list[Any]    ):
     create_state_space_tree(SCREAMING_SNAKE_CASE__      ,					[]      ,					0    )

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : list[Any]      ,					SCREAMING_SNAKE_CASE__      : list[Any]      ,					SCREAMING_SNAKE_CASE__      : int    ):

     if index == len(SCREAMING_SNAKE_CASE__    ):
          print(SCREAMING_SNAKE_CASE__    )
          return

     create_state_space_tree(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					index + 1    )
     current_subsequence.append(sequence[index]    )
     create_state_space_tree(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					index + 1    )
     current_subsequence.pop()


if __name__ == "__main__":
   _A			=						[3, 1, 2, 4]
   generate_all_subsequences(seq)

   seq.clear()
   seq.extend(['A', 'B', 'C'])
   generate_all_subsequences(seq)





