


'''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   _UpperCamelCase				(						)						->Any:
   UpperCAmelCase							=     1_0
   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""": [9_7], """text""": ["""1976"""]}] * 1_0,
           """id""": list(range(lowerCAmelCase_   )   ),
       }  ,						features=lowerCAmelCase_  ,						)
   return dataset
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->Union[str, Any]:
   UpperCAmelCase							=     str(tmp_path_factory.mktemp("""data"""   ) / """file.arrow"""   )
   dataset.map(cache_file_name=lowerCAmelCase_   )
   return filename


# FILE_CONTENT + files


__a     =			"""\\n    Text data.\n    Second line of data."""
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->int:
   UpperCAmelCase							=     tmp_path_factory.mktemp("""data"""   ) / """file.txt"""
   UpperCAmelCase							=     FILE_CONTENT
   with open(lowerCAmelCase_  ,						"""w"""   ) as f:
      f.write(lowerCAmelCase_   )
   return filename
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->Optional[int]:
   import bza

   UpperCAmelCase							=     tmp_path_factory.mktemp("""data"""   ) / """file.txt.bz2"""
   UpperCAmelCase							=     bytes(lowerCAmelCase_  ,						"""utf-8"""   )
   with bza.open(lowerCAmelCase_  ,						"""wb"""   ) as f:
      f.write(lowerCAmelCase_   )
   return path
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->int:
   import gzip

   UpperCAmelCase							=     str(tmp_path_factory.mktemp("""data"""   ) / """file.txt.gz"""   )
   UpperCAmelCase							=     bytes(lowerCAmelCase_  ,						"""utf-8"""   )
   with gzip.open(lowerCAmelCase_  ,						"""wb"""   ) as f:
      f.write(lowerCAmelCase_   )
   return path
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->Dict:
   if datasets.config.LZ4_AVAILABLE:
      import lza.frame

      UpperCAmelCase							=     tmp_path_factory.mktemp("""data"""   ) / """file.txt.lz4"""
      UpperCAmelCase							=     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

      UpperCAmelCase							=     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_   )						->Dict:
   import tarfile

   UpperCAmelCase							=     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_   )						->List[str]:
   import lzma

   UpperCAmelCase							=     tmp_path_factory.mktemp("""data"""   ) / """file.txt.xz"""
   UpperCAmelCase							=     bytes(lowerCAmelCase_  ,						"""utf-8"""   )
   with lzma.open(lowerCAmelCase_  ,						"""wb"""   ) as f:
      f.write(lowerCAmelCase_   )
   return path
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->Union[str, Any]:
   import zipfile

   UpperCAmelCase							=     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_   )						->str:
   if datasets.config.ZSTANDARD_AVAILABLE:
      import zstandard as zstd

      UpperCAmelCase							=     tmp_path_factory.mktemp("""data"""   ) / """file.txt.zst"""
      UpperCAmelCase							=     bytes(lowerCAmelCase_  ,						"""utf-8"""   )
      with zstd.open(lowerCAmelCase_  ,						"""wb"""   ) as f:
         f.write(lowerCAmelCase_   )
      return path
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->List[str]:
   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(lowerCAmelCase_  ,						"""w"""   ) as f:
      f.write(lowerCAmelCase_   )
   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				(						)						->List[str]:
   return DATA_DICT_OF_LISTS
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->Optional[int]:
   UpperCAmelCase							=     datasets.Dataset.from_dict(lowerCAmelCase_   )
   UpperCAmelCase							=     str(tmp_path_factory.mktemp("""data"""   ) / """dataset.arrow"""   )
   dataset.map(cache_file_name=lowerCAmelCase_   )
   return path
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->Tuple:
   UpperCAmelCase							=     str(tmp_path_factory.mktemp("""data"""   ) / """dataset.sqlite"""   )
   with contextlib.closing(sqlitea.connect(lowerCAmelCase_   )   ) 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				(						lowerCAmelCase_   )						->Any:
   UpperCAmelCase							=     str(tmp_path_factory.mktemp("""data"""   ) / """dataset.csv"""   )
   with open(lowerCAmelCase_  ,						"""w"""  ,						newline=""""""   ) as f:
      UpperCAmelCase							=     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]:
   UpperCAmelCase							=     str(tmp_path_factory.mktemp("""data"""   ) / """dataset2.csv"""   )
   with open(lowerCAmelCase_  ,						"""w"""  ,						newline=""""""   ) as f:
      UpperCAmelCase							=     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_   )						->List[str]:
   import bza

   UpperCAmelCase							=     tmp_path_factory.mktemp("""data"""   ) / """dataset.csv.bz2"""
   with open(lowerCAmelCase_  ,						"""rb"""   ) as f:
      UpperCAmelCase							=     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_   )						->List[Any]:
   UpperCAmelCase							=     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_   )						->Tuple:
   UpperCAmelCase							=     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_   )						->int:
   UpperCAmelCase							=     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_   )						->Any:
   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(lowerCAmelCase_  ,						"""wb"""   ) as f:
      UpperCAmelCase							=     pq.ParquetWriter(lowerCAmelCase_  ,						schema=lowerCAmelCase_   )
      UpperCAmelCase							=     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[int]:
   UpperCAmelCase							=     str(tmp_path_factory.mktemp("""data"""   ) / """dataset.json"""   )
   UpperCAmelCase							=     {"""data""": DATA}
   with open(lowerCAmelCase_  ,						"""w"""   ) as f:
      json.dump(lowerCAmelCase_  ,						lowerCAmelCase_   )
   return path
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->List[str]:
   UpperCAmelCase							=     str(tmp_path_factory.mktemp("""data"""   ) / """dataset.json"""   )
   UpperCAmelCase							=     {"""data""": DATA_DICT_OF_LISTS}
   with open(lowerCAmelCase_  ,						"""w"""   ) as f:
      json.dump(lowerCAmelCase_  ,						lowerCAmelCase_   )
   return path
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->Any:
   UpperCAmelCase							=     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:
   UpperCAmelCase							=     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_   )						->Dict:
   UpperCAmelCase							=     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]:
   UpperCAmelCase							=     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

   UpperCAmelCase							=     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_   )						->Union[str, Any]:
   import gzip

   UpperCAmelCase							=     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_   )						->Optional[int]:
   UpperCAmelCase							=     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_   )						->List[str]:
   UpperCAmelCase							=     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_   )						->Union[str, Any]:
   UpperCAmelCase							=     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[Any]:
   UpperCAmelCase							=     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_   )						->Tuple:
   UpperCAmelCase							=     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_   )						->List[str]:
   UpperCAmelCase							=     ["""0""", """1""", """2""", """3"""]
   UpperCAmelCase							=     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_   )						->str:
   UpperCAmelCase							=     ["""0""", """1""", """2""", """3"""]
   UpperCAmelCase							=     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[Any]:
   UpperCAmelCase							=     ["""0""", """1""", """2""", """3"""]
   UpperCAmelCase							=     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_   )						->List[str]:
   UpperCAmelCase							=     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_   )						->str:
   UpperCAmelCase							=     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_   )						->Optional[Any]:
   UpperCAmelCase							=     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_   )						->Union[str, Any]:
   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(lowerCAmelCase_  ,						"""w"""  ,						encoding="""utf-8"""   ) as f:
      f.write(lowerCAmelCase_   )
   return path
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						)						->str:
   return os.path.join("""tests"""  ,						"""features"""  ,						"""data"""  ,						"""test_image_rgb.jpg"""   )
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						)						->Optional[Any]:
   return os.path.join("""tests"""  ,						"""features"""  ,						"""data"""  ,						"""test_audio_44100.wav"""   )
@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->List[Any]:
   UpperCAmelCase							=     tmp_path_factory.mktemp("""data"""   ) / """dataset.img.zip"""
   with zipfile.ZipFile(lowerCAmelCase_  ,						"""w"""   ) as f:
      f.write(lowerCAmelCase_  ,						arcname=os.path.basename(lowerCAmelCase_   )   )
      f.write(lowerCAmelCase_  ,						arcname=os.path.basename(lowerCAmelCase_   ).replace(""".jpg"""  ,						"""2.jpg"""   )   )
   return path







@pytest.fixture(scope="""session"""   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->List[Any]:
   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""" * 1_0   )
   with open(data_dir / """subdir""" / """test.txt"""  ,						"""w"""   ) as f:
      f.write("""bar\n""" * 1_0   )
   # hidden file
   with open(data_dir / """subdir""" / """.test.txt"""  ,						"""w"""   ) as f:
      f.write("""bar\n""" * 1_0   )

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

   return data_dir







import math






class   __lowercase				:





      def        _lowercase				(		self						:					Union[str, Any]					,       __lowerCamelCase						:					list[list[float]]					,       __lowerCamelCase						:					list[int]       )    ->   int:






         """simple docstring"""







         UpperCAmelCase							=     0.0
         UpperCAmelCase							=     0.0
         for i in range(len(__lowerCamelCase       )       ):
            da += math.pow((sample[i] - weights[0][i])					,       2       )
            da += math.pow((sample[i] - weights[1][i])					,       2       )
            return 0 if da > da else 1
         return 0





      def        _lowercase				(		self						:					List[Any]					,       __lowerCamelCase						:					list[list[int | float]]					,       __lowerCamelCase						:					list[int]					,       __lowerCamelCase						:					int					,       __lowerCamelCase						:					float       )    ->   list[list[int | float]]:






         """simple docstring"""







         for i in range(len(__lowerCamelCase       )       ):
            weights[j][i] += alpha * (sample[i] - weights[j][i])
         return weights

def   _UpperCamelCase				(						)						->None:
   # Training Examples ( m, n )
   UpperCAmelCase							=     [[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

   # weight initialization ( n, C )
   UpperCAmelCase							=     [[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]

   # training
   UpperCAmelCase							=     SelfOrganizingMap()
   UpperCAmelCase							=     3
   UpperCAmelCase							=     0.5

   for _ in range(lowerCAmelCase_   ):
      for j in range(len(lowerCAmelCase_   )   ):
         # training sample
         UpperCAmelCase							=     training_samples[j]

         # Compute the winning vector
         UpperCAmelCase							=     self_organizing_map.get_winner(lowerCAmelCase_  ,						lowerCAmelCase_   )

         # Update the winning vector
         UpperCAmelCase							=     self_organizing_map.update(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_   )

    # classify test sample
   UpperCAmelCase							=     [0, 0, 0, 1]
   UpperCAmelCase							=     self_organizing_map.get_winner(lowerCAmelCase_  ,						lowerCAmelCase_   )

   # results
   print(F"""Clusters that the test sample belongs to : {winner}"""   )
   print(F"""Weights that have been trained : {weights}"""   )


# running the main() function
if __name__ == "__main__":
 main()



