

import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar



class SCREAMING_SNAKE_CASE     (  unittest.TestCase			):
  """simple docstring"""






  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]   )							->     Tuple:






     """simple docstring"""







     __lowerCAmelCase  :      Dict    =						logging.get_logger()

     # the current default level is logging.WARNING
     __lowerCAmelCase  :      Any    =						logging.get_verbosity()

     logging.set_verbosity_error()
     self.assertEqual(logger.getEffectiveLevel()	,							logging.get_verbosity()   )

     logging.set_verbosity_warning()
     self.assertEqual(logger.getEffectiveLevel()	,							logging.get_verbosity()   )

     logging.set_verbosity_info()
     self.assertEqual(logger.getEffectiveLevel()	,							logging.get_verbosity()   )

     logging.set_verbosity_debug()
     self.assertEqual(logger.getEffectiveLevel()	,							logging.get_verbosity()   )

     # restore to the original level
     logging.set_verbosity(snake_case_   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   int   )							->     Any:






     """simple docstring"""







     __lowerCAmelCase  :      Dict    =						logging.get_verbosity()

     __lowerCAmelCase  :      str    =						logging.get_logger("""transformers.models.bart.tokenization_bart"""   )
     __lowerCAmelCase  :      str    =						'''Testing 1, 2, 3'''

     # should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
     if level_origin <= logging.WARNING:
        with CaptureLogger(snake_case_   ) as cl:
           logger.warning(snake_case_   )
        self.assertEqual(cl.out	,							msg + """\n"""   )

     # this is setting the level for all of `transformers.*` loggers
     logging.set_verbosity_error()

     # should not be able to log warnings
     with CaptureLogger(snake_case_   ) as cl:
        logger.warning(snake_case_   )
     self.assertEqual(cl.out	,							""""""   )

     # should be able to log warnings again
     logging.set_verbosity_warning()
     with CaptureLogger(snake_case_   ) as cl:
        logger.warning(snake_case_   )
     self.assertEqual(cl.out	,							msg + """\n"""   )

     # restore to the original level
     logging.set_verbosity(snake_case_   )







  @mockenv(TRANSFORMERS_VERBOSITY="""error"""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Optional[int]   )							->     Optional[Any]:






     """simple docstring"""







     transformers.utils.logging._reset_library_root_logger()
     # this action activates the env var
     __lowerCAmelCase  :      Optional[Any]    =						logging.get_logger("""transformers.models.bart.tokenization_bart"""   )

     __lowerCAmelCase  :      List[str]    =						os.getenv("""TRANSFORMERS_VERBOSITY"""	,							snake_case_   )
     __lowerCAmelCase  :      Union[str, Any]    =						logging.log_levels[env_level_str]

     __lowerCAmelCase  :      int    =						logging.get_verbosity()
     self.assertEqual(
         snake_case_	,							snake_case_	,							f'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''	,							)

     # restore to the original level
     __lowerCAmelCase  :      str    =						''''''
     transformers.utils.logging._reset_library_root_logger()







  @mockenv(TRANSFORMERS_VERBOSITY="""super-error"""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   List[str]   )							->     Tuple:






     """simple docstring"""







     transformers.utils.logging._reset_library_root_logger()
     __lowerCAmelCase  :      Optional[int]    =						logging.logging.getLogger()
     with CaptureLogger(snake_case_   ) as cl:
        # this action activates the env var
        logging.get_logger("""transformers.models.bart.tokenization_bart"""   )
     self.assertIn("""Unknown option TRANSFORMERS_VERBOSITY=super-error"""	,							cl.out   )

     # no need to restore as nothing was changed







  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]   )							->     List[str]:






     """simple docstring"""







     transformers.utils.logging._reset_library_root_logger()

     __lowerCAmelCase  :      int    =						logging.get_logger("""transformers.models.bart.tokenization_bart"""   )
     __lowerCAmelCase  :      Union[str, Any]    =						'''Testing 1, 2, 3'''

     with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS="""1"""   ):
        # nothing should be logged as env var disables this method
        with CaptureLogger(snake_case_   ) as cl:
           logger.warning_advice(snake_case_   )
        self.assertEqual(cl.out	,							""""""   )

     with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=""""""   ):
        # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
        with CaptureLogger(snake_case_   ) as cl:
           logger.warning_advice(snake_case_   )
        self.assertEqual(cl.out	,							msg + """\n"""   )






def      snake_case_				()      ->     List[Any]:
   disable_progress_bar()
   assert are_progress_bars_disabled()

   enable_progress_bar()
   assert not are_progress_bars_disabled()





# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position

__UpperCAmelCase								=			"""2.13.1"""

import platform

import pyarrow
from packaging import version


if version.parse(platform.python_version()) < version.parse("""3.7"""):
   raise ImportWarning(
       """To use `datasets`, Python>=3.7 is required, and the current version of Python doesn't match this condition."""
   )

if version.parse(pyarrow.__version__).major < 8:
   raise ImportWarning(
       """To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn't match this condition.\n"""
       """If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`."""
   )

del platform
del pyarrow
del version

from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
    list_datasets,
    list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
    NamedSplit,
    NamedSplitAll,
    Split,
    SplitBase,
    SplitDict,
    SplitGenerator,
    SplitInfo,
    SubSplitInfo,
    percent,
)
from .tasks import *
from .utils import *
from .utils import logging


# deprecated modules
from datasets import arrow_dataset as _arrow_dataset  # isort:skip
from datasets import utils as _utils  # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip

__UpperCAmelCase								=			concatenate_datasets
__UpperCAmelCase								=			DownloadConfig
__UpperCAmelCase								=			DownloadManager
__UpperCAmelCase								=			DownloadMode
__UpperCAmelCase								=			DownloadConfig
__UpperCAmelCase								=			DownloadMode
__UpperCAmelCase								=			DownloadManager

del _arrow_dataset, _utils, _deprecated_download_manager


