
"""simple docstring"""





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__						(     )				->						Optional[Any]:


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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case      )				->						Optional[int]:


					"""simple docstring"""





					_UpperCamelCase									=    str(tmp_path_factory.mktemp('''data'''      ) / '''file.arrow'''      )
					dataset.map(cache_file_name=__snake_case      )
					return filename


# FILE_CONTENT + files


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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Dict:


					"""simple docstring"""





					_UpperCamelCase									=    tmp_path_factory.mktemp('''data'''      ) / '''file.txt'''
					_UpperCamelCase									=    FILE_CONTENT
					with open(__snake_case,	'''w'''      ) as f:
										f.write(__snake_case      )
					return filename



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Union[str, Any]:


					"""simple docstring"""





					import bza

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Optional[int]:


					"""simple docstring"""





					import gzip

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Dict:


					"""simple docstring"""





					if datasets.config.LZ4_AVAILABLE:
										import lza.frame

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case      )				->						Tuple:


					"""simple docstring"""





					if datasets.config.PY7ZR_AVAILABLE:
										import pyazr

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case      )				->						List[str]:


					"""simple docstring"""





					import tarfile

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Union[str, Any]:


					"""simple docstring"""





					import lzma

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case      )				->						int:


					"""simple docstring"""





					import zipfile

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						List[Any]:


					"""simple docstring"""





					if datasets.config.ZSTANDARD_AVAILABLE:
										import zstandard as zstd

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Optional[int]:


					"""simple docstring"""





					_UpperCamelCase									=    tmp_path_factory.mktemp('''data'''      ) / '''file.xml'''
					_UpperCamelCase									=    textwrap.dedent(
					    '''\
    <?xml version="1.0" encoding="UTF-8" ?>
    <tmx version="1.4">
      <header segtype="sentence" srclang="ca" />
      <body>
        <tu>
          <tuv xml:lang="ca"><seg>Contingut 1</seg></tuv>
          <tuv xml:lang="en"><seg>Content 1</seg></tuv>
        </tu>
        <tu>
          <tuv xml:lang="ca"><seg>Contingut 2</seg></tuv>
          <tuv xml:lang="en"><seg>Content 2</seg></tuv>
        </tu>
        <tu>
          <tuv xml:lang="ca"><seg>Contingut 3</seg></tuv>
          <tuv xml:lang="en"><seg>Content 3</seg></tuv>
        </tu>
        <tu>
          <tuv xml:lang="ca"><seg>Contingut 4</seg></tuv>
          <tuv xml:lang="en"><seg>Content 4</seg></tuv>
        </tu>
        <tu>
          <tuv xml:lang="ca"><seg>Contingut 5</seg></tuv>
          <tuv xml:lang="en"><seg>Content 5</seg></tuv>
        </tu>
      </body>
    </tmx>'''      )
					with open(__snake_case,	'''w'''      ) as f:
										f.write(__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  lowerCamelCase__						(     )				->						Optional[Any]:


					"""simple docstring"""





					return DATA_DICT_OF_LISTS



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						str:


					"""simple docstring"""





					_UpperCamelCase									=    datasets.Dataset.from_dict(__snake_case      )
					_UpperCamelCase									=    str(tmp_path_factory.mktemp('''data'''      ) / '''dataset.arrow'''      )
					dataset.map(cache_file_name=__snake_case      )
					return path



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						List[Any]:


					"""simple docstring"""





					_UpperCamelCase									=    str(tmp_path_factory.mktemp('''data'''      ) / '''dataset.sqlite'''      )
					with contextlib.closing(sqlitea.connect(__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  lowerCamelCase__						(     __snake_case      )				->						List[str]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						int:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case      )				->						Optional[int]:


					"""simple docstring"""





					import bza

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						Optional[int]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						Optional[Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						str:


					"""simple docstring"""





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



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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Optional[int]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Union[str, Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Optional[int]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						str:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Union[str, Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						List[str]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case      )				->						str:


					"""simple docstring"""





					import gzip

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case      )				->						int:


					"""simple docstring"""





					import gzip

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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						Union[str, Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case,	__snake_case      )				->						Optional[Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						Optional[Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						str:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case,	__snake_case      )				->						List[Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						str:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						str:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						str:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						Optional[Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						Optional[Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						List[str]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						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(__snake_case,	'''w''',	encoding='''utf-8'''      ) as f:
										f.write(__snake_case      )
					return path



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     )				->						List[Any]:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     )				->						int:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case,	__snake_case      )				->						Any:


					"""simple docstring"""





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



@pytest.fixture(scope='''session'''      )
def  lowerCamelCase__						(     __snake_case      )				->						Union[str, 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












from collections import UserDict
from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
						from PIL import Image

						from ..image_utils import load_image

if is_torch_available():
						from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING

if is_tf_available():
						from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
						from ..tf_utils import stable_softmax

SCREAMING_SNAKE_CASE:     Optional[int]									= logging.get_logger(__name__)



@add_end_docstrings(SCREAMING_SNAKE_CASE__ )
class    lowercase_		(SCREAMING_SNAKE_CASE__ ):



						def __init__(			self	:   Any					,							**snake_case__	:   str  ):

								"""simple docstring"""

								super().__init__(**snake_case__  )

								requires_backends(self					,							'vision'  )
								self.check_model_type(
								    TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
								    if self.framework == 'tf'
								    else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING  )



						def __call__(			self	:   str					,							snake_case__	:   Union[str, List[str], "Image", List["Image"]]					,							**snake_case__	:   Optional[Any]  ):

								"""simple docstring"""

								return super().__call__(snake_case__					,							**snake_case__  )



						def 	__a					(			self	:   str					,							**snake_case__	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							{}
								if "candidate_labels" in kwargs:
										SCREAMING_SNAKE_CASE_					      =							kwargs['candidate_labels']
								if "hypothesis_template" in kwargs:
										SCREAMING_SNAKE_CASE_					      =							kwargs['hypothesis_template']

								return preprocess_params, {}, {}



						def 	__a					(			self	:   List[str]					,							snake_case__	:   Optional[int]					,							snake_case__	:   Optional[Any]=None					,							snake_case__	:   List[str]="This is a photo of {}."  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							load_image(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							self.image_processor(images=[image]					,							return_tensors=self.framework  )
								SCREAMING_SNAKE_CASE_					      =							candidate_labels
								SCREAMING_SNAKE_CASE_					      =							[hypothesis_template.format(snake_case__  ) for x in candidate_labels]
								SCREAMING_SNAKE_CASE_					      =							self.tokenizer(snake_case__					,							return_tensors=self.framework					,							padding=snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							[text_inputs]
								return inputs



						def 	__a					(			self	:   List[Any]					,							snake_case__	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							model_inputs.pop('candidate_labels'  )
								SCREAMING_SNAKE_CASE_					      =							model_inputs.pop('text_inputs'  )
								if isinstance(text_inputs[0]					,							snake_case__  ):
										SCREAMING_SNAKE_CASE_					      =							text_inputs[0]
								else:
										# Batching case.
										SCREAMING_SNAKE_CASE_					      =							text_inputs[0][0]

								SCREAMING_SNAKE_CASE_					      =							self.model(**snake_case__					,							**snake_case__  )

								SCREAMING_SNAKE_CASE_					      =							{
								    'candidate_labels': candidate_labels,
								    'logits': outputs.logits_per_image,
								}
								return model_outputs






						def 	__a					(			self	:   List[Any]					,							snake_case__	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							model_outputs.pop('candidate_labels'  )
								SCREAMING_SNAKE_CASE_					      =							model_outputs['logits'][0]
								if self.framework == "pt":
										SCREAMING_SNAKE_CASE_					      =							logits.softmax(dim=-1  ).squeeze(-1  )
										SCREAMING_SNAKE_CASE_					      =							probs.tolist()
										if not isinstance(snake_case__					,							snake_case__  ):
												SCREAMING_SNAKE_CASE_					      =							[scores]
								elif self.framework == "tf":
										SCREAMING_SNAKE_CASE_					      =							stable_softmax(snake_case__					,							axis=-1  )
										SCREAMING_SNAKE_CASE_					      =							probs.numpy().tolist()
								else:
										raise ValueError(f'''Unsupported framework: {self.framework}'''  )

								SCREAMING_SNAKE_CASE_					      =							[
								    {'score': score, 'label': candidate_label}
								    for score, candidate_label in sorted(zip(snake_case__					,							snake_case__  )					,							key=lambda snake_case__  : -x[0]  )
								]
								return result