


import argparse
import re

import torch
from CLAP import create_model

from transformers import AutoFeatureExtractor, ClapConfig, ClapModel


SCREAMING_SNAKE_CASE			: Optional[Any]				   =					{
    "text_branch": "text_model",
    "audio_branch": "audio_model.audio_encoder",
    "attn": "attention.self",
    "self.proj": "output.dense",
    "attention.self_mask": "attn_mask",
    "mlp.fc1": "intermediate.dense",
    "mlp.fc2": "output.dense",
    "norm1": "layernorm_before",
    "norm2": "layernorm_after",
    "bn0": "batch_norm",
}

SCREAMING_SNAKE_CASE			: Dict				   =					AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused", truncation="rand_trunc")



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_=False					)       ->		Any:
    _lowercase						,							_lowercase			:				Dict 						=						create_model(
        'HTSAT-tiny'				,					'roberta'				,					lowerCamelCase_				,					precision='fp32'				,					device='cuda:0' if torch.cuda.is_available() else 'cpu'				,					enable_fusion=lowerCamelCase_				,					fusion_type='aff_2d' if enable_fusion else None				,					)
    return model, model_cfg



def 							UpperCamelCase_( lowerCamelCase_					)       ->		Any:
    _lowercase			:				Tuple 						=						{}

    _lowercase			:				Optional[Any] 						=						R'.*sequential.(\d+).*'
    _lowercase			:				Union[str, Any] 						=						R'.*_projection.(\d+).*'

    for key, value in state_dict.items():
        # check if any key needs to be modified
        for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
            if key_to_modify in key:
                _lowercase			:				str 						=						key.replace(lowerCamelCase_				,					lowerCamelCase_					)

        if re.match(lowerCamelCase_				,					lowerCamelCase_					):
            # replace sequential layers with list
            _lowercase			:				Dict 						=						re.match(lowerCamelCase_				,					lowerCamelCase_					).group(1					)

            _lowercase			:				List[Any] 						=						key.replace(F'''sequential.{sequential_layer}.'''				,					F'''layers.{int(lowerCamelCase_					)//3}.linear.'''					)
        elif re.match(lowerCamelCase_				,					lowerCamelCase_					):
            _lowercase			:				List[Any] 						=						int(re.match(lowerCamelCase_				,					lowerCamelCase_					).group(1					)					)

            # Because in CLAP they use `nn.Sequential`...
            _lowercase			:				str 						=						1 if projecton_layer == 0 else 2

            _lowercase			:				str 						=						key.replace(F'''_projection.{projecton_layer}.'''				,					F'''_projection.linear{transformers_projection_layer}.'''					)

        if "audio" and "qkv" in key:
            # split qkv into query key and value
            _lowercase			:				Union[str, Any] 						=						value
            _lowercase			:				Union[str, Any] 						=						mixed_qkv.size(0					) // 3

            _lowercase			:				Any 						=						mixed_qkv[:qkv_dim]
            _lowercase			:				Tuple 						=						mixed_qkv[qkv_dim : qkv_dim * 2]
            _lowercase			:				str 						=						mixed_qkv[qkv_dim * 2 :]

            _lowercase			:				Optional[Any] 						=						query_layer
            _lowercase			:				Optional[Any] 						=						key_layer
            _lowercase			:				int 						=						value_layer
        else:
            _lowercase			:				Optional[Any] 						=						value

    return model_state_dict



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_=False					)       ->		Optional[int]:
    _lowercase						,							_lowercase			:				Tuple 						=						init_clap(lowerCamelCase_				,					enable_fusion=lowerCamelCase_					)

    clap_model.eval()
    _lowercase			:				Optional[int] 						=						clap_model.state_dict()
    _lowercase			:				Dict 						=						rename_state_dict(lowerCamelCase_					)

    _lowercase			:				Optional[int] 						=						ClapConfig()
    _lowercase			:				Tuple 						=						enable_fusion
    _lowercase			:				int 						=						ClapModel(lowerCamelCase_					)

    # ignore the spectrogram embedding layer
    model.load_state_dict(lowerCamelCase_				,					strict=lowerCamelCase_					)

    model.save_pretrained(lowerCamelCase_					)
    transformers_config.save_pretrained(lowerCamelCase_					)


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE			: Union[str, Any]				   =					argparse.ArgumentParser()
 parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
 parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
 parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
 parser.add_argument("--enable_fusion", action="store_true", help="Whether to enable fusion or not")
 SCREAMING_SNAKE_CASE			: Union[str, Any]				   =					parser.parse_args()

 convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)






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_( )       ->		Any:
    _lowercase			:				str 						=						10
    _lowercase			:				List[str] 						=						datasets.Features(
        {
            'tokens': datasets.Sequence(datasets.Value('string'					)					),
            'labels': datasets.Sequence(datasets.ClassLabel(names=['negative', 'positive']					)					),
            'answers': datasets.Sequence(
                {
                    'text': datasets.Value('string'					),
                    'answer_start': datasets.Value('int32'					),
                }					),
            'id': datasets.Value('int64'					),
        }					)
    _lowercase			:				Union[str, Any] 						=						datasets.Dataset.from_dict(
        {
            'tokens': [['foo'] * 5] * n,
            'labels': [[1] * 5] * n,
            'answers': [{'answer_start': [97], 'text': ['1976']}] * 10,
            'id': list(range(lowerCamelCase_					)					),
        }				,					features=lowerCamelCase_				,					)
    return dataset



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		int:
    _lowercase			:				int 						=						str(tmp_path_factory.mktemp('data'					) / 'file.arrow'					)
    dataset.map(cache_file_name=lowerCamelCase_					)
    return filename


# FILE_CONTENT + files


SCREAMING_SNAKE_CASE			: str				   =					"\\n    Text data.\n    Second line of data."



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		List[Any]:
    _lowercase			:				str 						=						tmp_path_factory.mktemp('data'					) / 'file.txt'
    _lowercase			:				List[str] 						=						FILE_CONTENT
    with open(lowerCamelCase_				,					'w'					) as f:
        f.write(lowerCamelCase_					)
    return filename



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		Tuple:
    import bza

    _lowercase			:				Any 						=						tmp_path_factory.mktemp('data'					) / 'file.txt.bz2'
    _lowercase			:				Optional[Any] 						=						bytes(lowerCamelCase_				,					'utf-8'					)
    with bza.open(lowerCamelCase_				,					'wb'					) as f:
        f.write(lowerCamelCase_					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		List[Any]:
    import gzip

    _lowercase			:				Optional[int] 						=						str(tmp_path_factory.mktemp('data'					) / 'file.txt.gz'					)
    _lowercase			:				Optional[int] 						=						bytes(lowerCamelCase_				,					'utf-8'					)
    with gzip.open(lowerCamelCase_				,					'wb'					) as f:
        f.write(lowerCamelCase_					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		str:
    if datasets.config.LZ4_AVAILABLE:
        import lza.frame

        _lowercase			:				Any 						=						tmp_path_factory.mktemp('data'					) / 'file.txt.lz4'
        _lowercase			:				Optional[Any] 						=						bytes(lowerCamelCase_				,					'utf-8'					)
        with lza.frame.open(lowerCamelCase_				,					'wb'					) as f:
            f.write(lowerCamelCase_					)
        return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		str:
    if datasets.config.PY7ZR_AVAILABLE:
        import pyazr

        _lowercase			:				int 						=						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_				,					lowerCamelCase_					)       ->		List[str]:
    import tarfile

    _lowercase			:				Optional[Any] 						=						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_					)       ->		str:
    import lzma

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



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		str:
    import zipfile

    _lowercase			:				Dict 						=						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_					)       ->		Optional[Any]:
    if datasets.config.ZSTANDARD_AVAILABLE:
        import zstandard as zstd

        _lowercase			:				Optional[Any] 						=						tmp_path_factory.mktemp('data'					) / 'file.txt.zst'
        _lowercase			:				Dict 						=						bytes(lowerCamelCase_				,					'utf-8'					)
        with zstd.open(lowerCamelCase_				,					'wb'					) as f:
            f.write(lowerCamelCase_					)
        return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		str:
    _lowercase			:				Union[str, Any] 						=						tmp_path_factory.mktemp('data'					) / 'file.xml'
    _lowercase			:				Optional[Any] 						=						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


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

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

SCREAMING_SNAKE_CASE			: 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 							UpperCamelCase_( )       ->		List[str]:
    return DATA_DICT_OF_LISTS



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		Dict:
    _lowercase			:				Optional[int] 						=						datasets.Dataset.from_dict(lowerCamelCase_					)
    _lowercase			:				List[Any] 						=						str(tmp_path_factory.mktemp('data'					) / 'dataset.arrow'					)
    dataset.map(cache_file_name=lowerCamelCase_					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		str:
    _lowercase			:				List[str] 						=						str(tmp_path_factory.mktemp('data'					) / 'dataset.sqlite'					)
    with contextlib.closing(sqlitea.connect(lowerCamelCase_					)					) as con:
        _lowercase			:				Union[str, Any] 						=						con.cursor()
        cur.execute('CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)'					)
        for item in DATA:
            cur.execute('INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)'				,					tuple(item.values()					)					)
        con.commit()
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		Dict:
    _lowercase			:				List[str] 						=						str(tmp_path_factory.mktemp('data'					) / 'dataset.csv'					)
    with open(lowerCamelCase_				,					'w'				,					newline=''					) as f:
        _lowercase			:				Tuple 						=						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_					)       ->		List[Any]:
    _lowercase			:				Tuple 						=						str(tmp_path_factory.mktemp('data'					) / 'dataset2.csv'					)
    with open(lowerCamelCase_				,					'w'				,					newline=''					) as f:
        _lowercase			:				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_				,					lowerCamelCase_					)       ->		Any:
    import bza

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



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		Any:
    _lowercase			:				Tuple 						=						str(tmp_path_factory.mktemp('data'					) / 'dataset.json'					)
    _lowercase			:				Optional[Any] 						=						{'data': DATA_DICT_OF_LISTS}
    with open(lowerCamelCase_				,					'w'					) as f:
        json.dump(lowerCamelCase_				,					lowerCamelCase_					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		Union[str, Any]:
    _lowercase			:				Any 						=						str(tmp_path_factory.mktemp('data'					) / 'dataset.jsonl'					)
    with open(lowerCamelCase_				,					'w'					) as f:
        for item in DATA:
            f.write(json.dumps(lowerCamelCase_					) + '\n'					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		Dict:
    _lowercase			:				Dict 						=						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_					)       ->		List[str]:
    _lowercase			:				Optional[Any] 						=						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_					)       ->		List[Any]:
    _lowercase			:				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_				,					lowerCamelCase_					)       ->		Optional[Any]:
    import gzip

    _lowercase			:				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_				,					lowerCamelCase_					)       ->		Dict:
    import gzip

    _lowercase			:				Optional[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_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		List[str]:
    _lowercase			:				Any 						=						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_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		str:
    _lowercase			:				str 						=						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_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		int:
    _lowercase			:				Optional[Any] 						=						tmp_path_factory.mktemp('data'					) / 'dataset_with_dir.jsonl.zip'
    with zipfile.ZipFile(lowerCamelCase_				,					'w'					) as f:
        f.write(lowerCamelCase_				,					arcname=os.path.join('main_dir'				,					os.path.basename(lowerCamelCase_					)					)					)
        f.write(lowerCamelCase_				,					arcname=os.path.join('main_dir'				,					os.path.basename(lowerCamelCase_					)					)					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		Optional[int]:
    _lowercase			:				Tuple 						=						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_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		Any:
    _lowercase			:				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_					)       ->		Any:
    _lowercase			:				Optional[int] 						=						['0', '1', '2', '3']
    _lowercase			:				str 						=						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_					)       ->		Union[str, Any]:
    _lowercase			:				str 						=						['0', '1', '2', '3']
    _lowercase			:				List[Any] 						=						str(tmp_path_factory.mktemp('data'					) / 'dataset2.txt'					)
    with open(lowerCamelCase_				,					'w'					) as f:
        for item in data:
            f.write(item + '\n'					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_					)       ->		List[str]:
    _lowercase			:				List[Any] 						=						['0', '1', '2', '3']
    _lowercase			:				Optional[int] 						=						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_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		Any:
    _lowercase			:				Optional[Any] 						=						tmp_path_factory.mktemp('data'					) / 'dataset.text.zip'
    with zipfile.ZipFile(lowerCamelCase_				,					'w'					) as f:
        f.write(lowerCamelCase_				,					arcname=os.path.basename(lowerCamelCase_					)					)
        f.write(lowerCamelCase_				,					arcname=os.path.basename(lowerCamelCase_					)					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		Dict:
    _lowercase			:				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_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		str:
    _lowercase			:				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_					)       ->		int:
    _lowercase			:				List[str] 						=						'\n'.join(['First', 'Second\u2029with Unicode new line', 'Third']					)
    _lowercase			:				Any 						=						str(tmp_path_factory.mktemp('data'					) / 'dataset_with_unicode_new_lines.txt'					)
    with open(lowerCamelCase_				,					'w'				,					encoding='utf-8'					) as f:
        f.write(lowerCamelCase_					)
    return path



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( )       ->		Dict:
    return os.path.join('tests'				,					'features'				,					'data'				,					'test_image_rgb.jpg'					)



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( )       ->		int:
    return os.path.join('tests'				,					'features'				,					'data'				,					'test_audio_44100.wav'					)



@pytest.fixture(scope='session'					)
def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		Any:
    _lowercase			:				Dict 						=						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_					)       ->		Optional[Any]:
    _lowercase			:				str 						=						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


