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_ (     )     ->				Union[str, 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(__A							)							),
          },  features=__A,  )
      return dataset




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A							)     ->				List[Any]:







      '''simple docstring'''


      UpperCAmelCase__								=  str(tmp_path_factory.mktemp("data"							) / "file.arrow"							)
      dataset.map(cache_file_name=__A							)
      return filename


# FILE_CONTENT + files


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Tuple:







      '''simple docstring'''


      UpperCAmelCase__								=  tmp_path_factory.mktemp("data"							) / "file.txt"
      UpperCAmelCase__								=  FILE_CONTENT
      with open(__A,  "w"							) as f:
            f.write(__A							)
      return filename




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Dict:







      '''simple docstring'''


      import bza

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Optional[int]:







      '''simple docstring'''


      import gzip

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Tuple:







      '''simple docstring'''


      if datasets.config.LZ4_AVAILABLE:
            import lza.frame

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A							)     ->				Tuple:







      '''simple docstring'''


      if datasets.config.PY7ZR_AVAILABLE:
            import pyazr

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A							)     ->				Dict:







      '''simple docstring'''


      import tarfile

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Optional[int]:







      '''simple docstring'''


      import lzma

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A							)     ->				Tuple:







      '''simple docstring'''


      import zipfile

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Optional[int]:







      '''simple docstring'''


      if datasets.config.ZSTANDARD_AVAILABLE:
            import zstandard as zstd

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Optional[Any]:







      '''simple docstring'''


      UpperCAmelCase__								=  tmp_path_factory.mktemp("data"							) / "file.xml"
      UpperCAmelCase__								=  textwrap.dedent(
          "\\n    <?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n    <tmx version=\"1.4\">\n      <header segtype=\"sentence\" srclang=\"ca\" />\n      <body>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 1</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 1</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 2</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 2</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 3</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 3</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 4</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 4</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 5</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 5</seg></tuv>\n        </tu>\n      </body>\n    </tmx>"							)
      with open(__A,  "w"							) as f:
            f.write(__A							)
      return filename


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

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

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







      '''simple docstring'''


      return DATA_DICT_OF_LISTS




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Dict:







      '''simple docstring'''


      UpperCAmelCase__								=  datasets.Dataset.from_dict(__A							)
      UpperCAmelCase__								=  str(tmp_path_factory.mktemp("data"							) / "dataset.arrow"							)
      dataset.map(cache_file_name=__A							)
      return path




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Any:







      '''simple docstring'''


      UpperCAmelCase__								=  str(tmp_path_factory.mktemp("data"							) / "dataset.sqlite"							)
      with contextlib.closing(sqlitea.connect(__A							)							) 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_ (     __A							)     ->				List[str]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				str:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A							)     ->				Dict:







      '''simple docstring'''


      import bza

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				Optional[Any]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				Dict:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				Dict:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Dict:







      '''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(__A,  "wb"							) as f:
            UpperCAmelCase__								=  pq.ParquetWriter(__A,  schema=__A							)
            UpperCAmelCase__								=  pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(__A							)							)] for k in DATA[0]},  schema=__A							)
            writer.write_table(__A							)
            writer.close()
      return path




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Any:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				List[Any]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Any:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Optional[int]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				int:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				str:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A							)     ->				List[str]:







      '''simple docstring'''


      import gzip

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A							)     ->				Tuple:







      '''simple docstring'''


      import gzip

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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				Optional[int]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A,  __A							)     ->				Any:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				Dict:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				Any:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A,  __A							)     ->				List[str]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				int:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Union[str, Any]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Optional[int]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				int:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				Optional[int]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A,  __A							)     ->				Tuple:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				Union[str, 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(__A,  "w",  encoding="utf-8"							) as f:
            f.write(__A							)
      return path




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     )     ->				Any:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     )     ->				List[str]:







      '''simple docstring'''


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




@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A,  __A							)     ->				Optional[int]:







      '''simple docstring'''


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







@pytest.fixture(scope="session"							)
def    lowerCAmelCase_ (     __A							)     ->				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 .dependency_versions_table import deps
from .utils.versions import require_version, require_version_core


# define which module versions we always want to check at run time
# (usually the ones defined in `install_requires` in setup.py)
#
# order specific notes:
# - tqdm must be checked before tokenizers

UpperCamelCase__											=					[
    'python',
    'tqdm',
    'regex',
    'requests',
    'packaging',
    'filelock',
    'numpy',
    'tokenizers',
    'huggingface-hub',
    'safetensors',
    'accelerate',
    'pyyaml',
]

for pkg in pkgs_to_check_at_runtime:
      if pkg in deps:
            if pkg == "tokenizers":
                  # must be loaded here, or else tqdm check may fail
                  from .utils import is_tokenizers_available

                  if not is_tokenizers_available():
                        continue  # not required, check version only if installed
            elif pkg == "accelerate":
                  # must be loaded here, or else tqdm check may fail
                  from .utils import is_accelerate_available

                  # Maybe switch to is_torch_available in the future here so that Accelerate is hard dep of
                  # Transformers with PyTorch
                  if not is_accelerate_available():
                        continue  # not required, check version only if installed

            require_version_core(deps[pkg])
      else:
            raise ValueError(f'''can\'t find {pkg} in {deps.keys()}, check dependency_versions_table.py''')




def    lowerCAmelCase_ (     __A,  __A=None							)     ->				Dict:







      '''simple docstring'''


      require_version(deps[pkg],  __A							)



