





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_    (    )	->				Dict:
     '''simple docstring'''


     A_          =       10
     A_          =       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'''				),
         }				)
     A_          =       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_    (    _UpperCAmelCase							:Any  ,						_UpperCAmelCase							:Tuple				)	->				Dict:
     '''simple docstring'''


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


# FILE_CONTENT + files


a__      :     Optional[int]         =		'\\n    Text data.\n    Second line of data.'

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:Any				)	->				Union[str, Any]:
     '''simple docstring'''


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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:int				)	->				Any:
     '''simple docstring'''


     import bza

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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:int				)	->				int:
     '''simple docstring'''


     import gzip

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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:List[str]				)	->				str:
     '''simple docstring'''


     if datasets.config.LZ4_AVAILABLE:
          import lza.frame

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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:int  ,						_UpperCAmelCase							:int				)	->				str:
     '''simple docstring'''


     if datasets.config.PY7ZR_AVAILABLE:
          import pyazr

          A_          =       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_    (    _UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:Optional[Any]				)	->				Any:
     '''simple docstring'''


     import tarfile

     A_          =       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_    (    _UpperCAmelCase							:Union[str, Any]				)	->				int:
     '''simple docstring'''


     import lzma

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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:Optional[int]  ,						_UpperCAmelCase							:int				)	->				Optional[Any]:
     '''simple docstring'''


     import zipfile

     A_          =       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_    (    _UpperCAmelCase							:int				)	->				List[Any]:
     '''simple docstring'''


     if datasets.config.ZSTANDARD_AVAILABLE:
          import zstandard as zstd

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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:Optional[Any]				)	->				Any:
     '''simple docstring'''


     A_          =       tmp_path_factory.mktemp('''data'''				) / '''file.xml'''
     A_          =       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(__lowerCamelCase  ,						'''w'''				) as f:
          f.write(__lowerCamelCase				)
     return filename


a__      :     Any         =		[
    {'col_1': '0', 'col_2': 0, 'col_3': 0.0},
    {'col_1': '1', 'col_2': 1, 'col_3': 1.0},
    {'col_1': '2', 'col_2': 2, 'col_3': 2.0},
    {'col_1': '3', 'col_2': 3, 'col_3': 3.0},
]
a__      :     Tuple         =		[
    {'col_1': '4', 'col_2': 4, 'col_3': 4.0},
    {'col_1': '5', 'col_2': 5, 'col_3': 5.0},
]
a__      :     Tuple         =		{
    'col_1': ['0', '1', '2', '3'],
    'col_2': [0, 1, 2, 3],
    'col_3': [0.0, 1.0, 2.0, 3.0],
}

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

a__      :     Tuple         =		[
    {'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_    (    )	->				Union[str, Any]:
     '''simple docstring'''


     return DATA_DICT_OF_LISTS

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:Tuple				)	->				Tuple:
     '''simple docstring'''


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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:List[str]				)	->				str:
     '''simple docstring'''


     A_          =       str(tmp_path_factory.mktemp('''data'''				) / '''dataset.sqlite'''				)
     with contextlib.closing(sqlitea.connect(__lowerCamelCase				)				) as con:
          A_          =       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_    (    _UpperCAmelCase							:Dict				)	->				Any:
     '''simple docstring'''


     A_          =       str(tmp_path_factory.mktemp('''data'''				) / '''dataset.csv'''				)
     with open(__lowerCamelCase  ,						'''w'''  ,						newline=''''''				) as f:
          A_          =       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_    (    _UpperCAmelCase							:Optional[int]				)	->				Tuple:
     '''simple docstring'''


     A_          =       str(tmp_path_factory.mktemp('''data'''				) / '''dataset2.csv'''				)
     with open(__lowerCamelCase  ,						'''w'''  ,						newline=''''''				) as f:
          A_          =       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_    (    _UpperCAmelCase							:Any  ,						_UpperCAmelCase							:int				)	->				int:
     '''simple docstring'''


     import bza

     A_          =       tmp_path_factory.mktemp('''data'''				) / '''dataset.csv.bz2'''
     with open(__lowerCamelCase  ,						'''rb'''				) as f:
          A_          =       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_    (    _UpperCAmelCase							:str  ,						_UpperCAmelCase							:Optional[Any]  ,						_UpperCAmelCase							:Optional[int]				)	->				List[str]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:int  ,						_UpperCAmelCase							:Union[str, Any]				)	->				int:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Dict  ,						_UpperCAmelCase							:Optional[int]  ,						_UpperCAmelCase							:List[str]				)	->				List[Any]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Tuple				)	->				Dict:
     '''simple docstring'''


     A_          =       str(tmp_path_factory.mktemp('''data'''				) / '''dataset.parquet'''				)
     A_          =       pa.schema(
         {
             '''col_1''': pa.string(),
             '''col_2''': pa.intaa(),
             '''col_3''': pa.floataa(),
         }				)
     with open(__lowerCamelCase  ,						'''wb'''				) as f:
          A_          =       pq.ParquetWriter(__lowerCamelCase  ,						schema=__lowerCamelCase				)
          A_          =       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_    (    _UpperCAmelCase							:Optional[Any]				)	->				str:
     '''simple docstring'''


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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:Dict				)	->				Optional[Any]:
     '''simple docstring'''


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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:Union[str, Any]				)	->				List[str]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Optional[int]				)	->				Any:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Optional[int]				)	->				Optional[Any]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:List[str]				)	->				Union[str, Any]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Union[str, Any]  ,						_UpperCAmelCase							:int				)	->				Optional[int]:
     '''simple docstring'''


     import gzip

     A_          =       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_    (    _UpperCAmelCase							:List[Any]  ,						_UpperCAmelCase							:int				)	->				Dict:
     '''simple docstring'''


     import gzip

     A_          =       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_    (    _UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:List[str]				)	->				List[str]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:List[Any]  ,						_UpperCAmelCase							:List[Any]  ,						_UpperCAmelCase							:List[Any]  ,						_UpperCAmelCase							:Any				)	->				Optional[int]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:int  ,						_UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:Union[str, Any]				)	->				List[str]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Any  ,						_UpperCAmelCase							:Union[str, Any]  ,						_UpperCAmelCase							:List[Any]				)	->				Optional[int]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:Dict  ,						_UpperCAmelCase							:Optional[int]  ,						_UpperCAmelCase							:Dict				)	->				Optional[int]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Union[str, Any]				)	->				Union[str, Any]:
     '''simple docstring'''


     A_          =       ['''0''', '''1''', '''2''', '''3''']
     A_          =       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_    (    _UpperCAmelCase							:Any				)	->				List[str]:
     '''simple docstring'''


     A_          =       ['''0''', '''1''', '''2''', '''3''']
     A_          =       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_    (    _UpperCAmelCase							:Any				)	->				List[str]:
     '''simple docstring'''


     A_          =       ['''0''', '''1''', '''2''', '''3''']
     A_          =       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_    (    _UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:Tuple  ,						_UpperCAmelCase							:Union[str, Any]				)	->				Any:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Optional[Any]  ,						_UpperCAmelCase							:List[Any]  ,						_UpperCAmelCase							:int				)	->				Optional[Any]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Union[str, Any]  ,						_UpperCAmelCase							:Union[str, Any]  ,						_UpperCAmelCase							:str				)	->				List[str]:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Dict				)	->				Dict:
     '''simple docstring'''


     A_          =       '''\n'''.join(['''First''', '''Second\u2029with Unicode new line''', '''Third''']				)
     A_          =       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_    (    )	->				Tuple:
     '''simple docstring'''


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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    )	->				List[str]:
     '''simple docstring'''


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

@pytest.fixture(scope='''session'''				)
def      UpperCAmelCase_    (    _UpperCAmelCase							:Dict  ,						_UpperCAmelCase							:Optional[Any]				)	->				Any:
     '''simple docstring'''


     A_          =       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_    (    _UpperCAmelCase							:Optional[int]				)	->				int:
     '''simple docstring'''


     A_          =       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 Counter

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split

lowercase_													=      datasets.load_iris()

lowercase_													=      np.array(data['''data'''])
lowercase_													=      np.array(data['''target'''])
lowercase_													=      data['''target_names''']

lowercase_							,							lowercase_							,							lowercase_							,							lowercase_													=      train_test_split(X, y)






def        __lowerCAmelCase		(	__lowerCamelCase						:     Optional[Any]					, __lowerCamelCase						:     Optional[Any]						)	->    Optional[int]:
					return np.linalg.norm(np.array(__lowerCamelCase						) - np.array(__lowerCamelCase						)						)






def        __lowerCAmelCase		(	__lowerCamelCase						:     List[str]					, __lowerCamelCase						:     List[Any]					, __lowerCamelCase						:     List[Any]					, __lowerCamelCase						:     Union[str, Any]					, __lowerCamelCase						:     int=5						)	->    str:
					__lowerCAmelCase						 =zip(__lowerCamelCase					, __lowerCamelCase						)
					# List of distances of all points from the point to be classified
					__lowerCAmelCase						 =[]
					for data_point in data:
										__lowerCAmelCase						 =euclidean_distance(data_point[0]					, __lowerCamelCase						)
										distances.append((distance, data_point[1])						)
					# Choosing 'k' points with the least distances.
					__lowerCAmelCase						 =[i[1] for i in sorted(__lowerCamelCase						)[:k]]
					# Most commonly occurring class among them
					# is the class into which the point is classified
					__lowerCAmelCase						 =Counter(__lowerCamelCase						).most_common(1						)[0][0]
					return classes[result]


if __name__ == "__main__":
				print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))




