
import importlib
import os
import platform
from pathlib import Path

from packaging import version

from .utils.logging import get_logger


__UpperCAmelCase   						=     get_logger(__name__)

# Datasets
__UpperCAmelCase   						=     "https://s3.amazonaws.com/datasets.huggingface.co/datasets/datasets"
__UpperCAmelCase   						=     "https://cdn-datasets.huggingface.co/datasets/datasets"
__UpperCAmelCase   						=     "https://raw.githubusercontent.com/huggingface/datasets/{revision}/datasets/{path}/{name}"

# Metrics
__UpperCAmelCase   						=     "https://s3.amazonaws.com/datasets.huggingface.co/datasets/metrics"
__UpperCAmelCase   						=     "https://cdn-datasets.huggingface.co/datasets/metric"
__UpperCAmelCase   						=     "https://raw.githubusercontent.com/huggingface/datasets/{revision}/metrics/{path}/{name}"

# Hub
__UpperCAmelCase   						=     os.environ.get("HF_ENDPOINT", "https://huggingface.co")
__UpperCAmelCase   						=     HF_ENDPOINT + "/datasets/{repo_id}/resolve/{revision}/{path}"
__UpperCAmelCase   						=     "main"

__UpperCAmelCase   						=     version.parse(platform.python_version())

if PY_VERSION < version.parse("3.8"):
   import importlib_metadata
else:
   import importlib.metadata as importlib_metadata

# General environment variables accepted values for booleans
__UpperCAmelCase   						=     {"1", "ON", "YES", "TRUE"}
__UpperCAmelCase   						=     ENV_VARS_TRUE_VALUES.union({"AUTO"})


# Imports
__UpperCAmelCase   						=     version.parse(importlib_metadata.version("dill"))
__UpperCAmelCase   						=     version.parse(importlib_metadata.version("pandas"))
__UpperCAmelCase   						=     version.parse(importlib_metadata.version("pyarrow"))

__UpperCAmelCase   						=     os.environ.get("USE_TF", "AUTO").upper()
__UpperCAmelCase   						=     os.environ.get("USE_TORCH", "AUTO").upper()
__UpperCAmelCase   						=     os.environ.get("USE_JAX", "AUTO").upper()

__UpperCAmelCase   						=     "N/A"
__UpperCAmelCase   						=     False

if USE_TORCH in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TF not in ENV_VARS_TRUE_VALUES:
   __UpperCAmelCase   						=     importlib.util.find_spec("torch") is not None
   if TORCH_AVAILABLE:
      try:
         __UpperCAmelCase   						=     version.parse(importlib_metadata.version("torch"))
         logger.info(F"""PyTorch version {TORCH_VERSION} available.""")
      except importlib_metadata.PackageNotFoundError:
         pass
else:
   logger.info("Disabling PyTorch because USE_TF is set")

__UpperCAmelCase   						=     "N/A"
__UpperCAmelCase   						=     False

if USE_TF in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TORCH not in ENV_VARS_TRUE_VALUES:
   __UpperCAmelCase   						=     importlib.util.find_spec("tensorflow") is not None
   if TF_AVAILABLE:
      # For the metadata, we have to look for both tensorflow and tensorflow-cpu
      for package in [
          "tensorflow",
          "tensorflow-cpu",
          "tensorflow-gpu",
          "tf-nightly",
          "tf-nightly-cpu",
          "tf-nightly-gpu",
          "intel-tensorflow",
          "tensorflow-rocm",
          "tensorflow-macos",
      ]:
         try:
            __UpperCAmelCase   						=     version.parse(importlib_metadata.version(package))
         except importlib_metadata.PackageNotFoundError:
            continue
         else:
            break
      else:
         __UpperCAmelCase   						=     False
   if TF_AVAILABLE:
      if TF_VERSION.major < 2:
         logger.info(F"""TensorFlow found but with version {TF_VERSION}. `datasets` requires version 2 minimum.""")
         __UpperCAmelCase   						=     False
      else:
         logger.info(F"""TensorFlow version {TF_VERSION} available.""")
else:
   logger.info("Disabling Tensorflow because USE_TORCH is set")


__UpperCAmelCase   						=     "N/A"
__UpperCAmelCase   						=     False

if USE_JAX in ENV_VARS_TRUE_AND_AUTO_VALUES:
   __UpperCAmelCase   						=     importlib.util.find_spec("jax") is not None and importlib.util.find_spec("jaxlib") is not None
   if JAX_AVAILABLE:
      try:
         __UpperCAmelCase   						=     version.parse(importlib_metadata.version("jax"))
         logger.info(F"""JAX version {JAX_VERSION} available.""")
      except importlib_metadata.PackageNotFoundError:
         pass
else:
   logger.info("Disabling JAX because USE_JAX is set to False")


__UpperCAmelCase   						=     os.environ.get("USE_BEAM", "AUTO").upper()
__UpperCAmelCase   						=     "N/A"
__UpperCAmelCase   						=     False
if USE_BEAM in ENV_VARS_TRUE_AND_AUTO_VALUES:
   try:
      __UpperCAmelCase   						=     version.parse(importlib_metadata.version("apache_beam"))
      __UpperCAmelCase   						=     True
      logger.info(F"""Apache Beam version {BEAM_VERSION} available.""")
   except importlib_metadata.PackageNotFoundError:
      pass
else:
   logger.info("Disabling Apache Beam because USE_BEAM is set to False")


# Optional tools for data loading
__UpperCAmelCase   						=     importlib.util.find_spec("sqlalchemy") is not None

# Optional tools for feature decoding
__UpperCAmelCase   						=     importlib.util.find_spec("PIL") is not None
__UpperCAmelCase   						=     importlib.util.find_spec("soundfile") is not None and version.parse(
    importlib.import_module("soundfile").__libsndfile_version__
) >= version.parse("1.0.31")
__UpperCAmelCase   						=     importlib.util.find_spec("soundfile") is not None and version.parse(
    importlib.import_module("soundfile").__libsndfile_version__
) >= version.parse("1.1.0")

# Optional compression tools
__UpperCAmelCase   						=     importlib.util.find_spec("rarfile") is not None
__UpperCAmelCase   						=     importlib.util.find_spec("zstandard") is not None
__UpperCAmelCase   						=     importlib.util.find_spec("lz4") is not None
__UpperCAmelCase   						=     importlib.util.find_spec("py7zr") is not None


# Cache location
__UpperCAmelCase   						=     "~/.cache"
__UpperCAmelCase   						=     os.getenv("XDG_CACHE_HOME", DEFAULT_XDG_CACHE_HOME)
__UpperCAmelCase   						=     os.path.join(XDG_CACHE_HOME, "huggingface")
__UpperCAmelCase   						=     os.path.expanduser(os.getenv("HF_HOME", DEFAULT_HF_CACHE_HOME))

__UpperCAmelCase   						=     os.path.join(HF_CACHE_HOME, "datasets")
__UpperCAmelCase   						=     Path(os.getenv("HF_DATASETS_CACHE", DEFAULT_HF_DATASETS_CACHE))

__UpperCAmelCase   						=     os.path.join(HF_CACHE_HOME, "metrics")
__UpperCAmelCase   						=     Path(os.getenv("HF_METRICS_CACHE", DEFAULT_HF_METRICS_CACHE))

__UpperCAmelCase   						=     os.path.join(HF_CACHE_HOME, "modules")
__UpperCAmelCase   						=     Path(os.getenv("HF_MODULES_CACHE", DEFAULT_HF_MODULES_CACHE))

__UpperCAmelCase   						=     "downloads"
__UpperCAmelCase   						=     os.path.join(HF_DATASETS_CACHE, DOWNLOADED_DATASETS_DIR)
__UpperCAmelCase   						=     Path(os.getenv("HF_DATASETS_DOWNLOADED_DATASETS_PATH", DEFAULT_DOWNLOADED_DATASETS_PATH))

__UpperCAmelCase   						=     "extracted"
__UpperCAmelCase   						=     os.path.join(DEFAULT_DOWNLOADED_DATASETS_PATH, EXTRACTED_DATASETS_DIR)
__UpperCAmelCase   						=     Path(os.getenv("HF_DATASETS_EXTRACTED_DATASETS_PATH", DEFAULT_EXTRACTED_DATASETS_PATH))

# Download count for the website
__UpperCAmelCase   						=     (
    os.environ.get("HF_UPDATE_DOWNLOAD_COUNTS", "AUTO").upper() in ENV_VARS_TRUE_AND_AUTO_VALUES
)

# Batch size constants. For more info, see:
# https://github.com/apache/arrow/blob/master/docs/source/cpp/arrays.rst#size-limitations-and-recommendations)
__UpperCAmelCase   						=     10_00

# Size of the preloaded record batch in `Dataset.__iter__`
__UpperCAmelCase   						=     10

# Pickling tables works only for small tables (<4GiB)
# For big tables, we write them on disk instead
__UpperCAmelCase   						=     4 << 30

# Max shard size in bytes (e.g. to shard parquet datasets in push_to_hub or download_and_prepare)
__UpperCAmelCase   						=     "500MB"

# Parquet configuration
__UpperCAmelCase   						=     1_00
__UpperCAmelCase   						=     1_00
__UpperCAmelCase   						=     1_00

# Offline mode
__UpperCAmelCase   						=     os.environ.get("HF_DATASETS_OFFLINE", "AUTO").upper() in ENV_VARS_TRUE_VALUES

# In-memory
__UpperCAmelCase   						=     0  # Disabled
__UpperCAmelCase   						=     float(os.environ.get("HF_DATASETS_IN_MEMORY_MAX_SIZE", DEFAULT_IN_MEMORY_MAX_SIZE))

# File names
__UpperCAmelCase   						=     "dataset.arrow"
__UpperCAmelCase   						=     "indices.arrow"
__UpperCAmelCase   						=     "state.json"
__UpperCAmelCase   						=     "dataset_info.json"
__UpperCAmelCase   						=     "dataset_infos.json"
__UpperCAmelCase   						=     "LICENSE"
__UpperCAmelCase   						=     "metric_info.json"
__UpperCAmelCase   						=     "dataset_dict.json"

__UpperCAmelCase   						=     "datasets_modules"

__UpperCAmelCase   						=     2_55

# Streaming
__UpperCAmelCase   						=     20
__UpperCAmelCase   						=     5

# Datasets without script
__UpperCAmelCase   						=     2_00
__UpperCAmelCase   						=     10
__UpperCAmelCase   						=     2_00

# Progress bars
__UpperCAmelCase   						=     0.05  # 20 progress updates per sec




from math import sqrt


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      [1]
   for i in range(2,  int(sqrt(__lowerCamelCase						)						) + 1,  1						):
      if number % i == 0:
         values.append(__lowerCamelCase						)
         if int(number // i						) != i:
            values.append(int(number // i						)						)
   return sorted(__lowerCamelCase						)


def  A__ (       __lowerCamelCase						):
   return sum(factors(__lowerCamelCase						)						) > n


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      factors(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      [[0 for i in range(number + 1						)] for j in range(r + 1						)]
   for i in range(r + 1						):
      SCREAMING_SNAKE_CASE_	=      True

   for i in range(1,  number + 1						):
      SCREAMING_SNAKE_CASE_	=      False

   for i in range(1,  r + 1						):
      for j in range(1,  number + 1						):
         if j < values[i - 1]:
            SCREAMING_SNAKE_CASE_	=      subset[i - 1][j]
         else:
            SCREAMING_SNAKE_CASE_	=      subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

   return subset[r][number] != 0


def  A__ (       __lowerCamelCase						):
   return abundant(__lowerCamelCase						) and not semi_perfect(__lowerCamelCase						)


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)
   for number in (69, 70, 71):
      print(F"""{number} is {'' if weird(number) else 'not '}weird.""")


