





'''simple docstring'''


import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


lowerCAmelCase :					List[Any] 							={
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

lowerCAmelCase :					int 							=logging.WARNING
def 							UpperCAmelCase_  (						):
   lowercase_      :int         =			os.getenv("DATASETS_VERBOSITY"     ,SCREAMING_SNAKE_CASE_			)
   if env_level_str:
      if env_level_str in log_levels:
         return log_levels[env_level_str]
      else:
         logging.getLogger().warning(
             F'Unknown option DATASETS_VERBOSITY={env_level_str}, '
             F'has to be one of: { ", ".join(log_levels.keys()			) }'			)
   return _default_log_level
def 							UpperCAmelCase_  (						):
   return __name__.split("."			)[0]
def 							UpperCAmelCase_  (						):
   return logging.getLogger(_get_library_name()			)
def 							UpperCAmelCase_  (						):
   # Apply our default configuration to the library root logger.
   lowercase_      :List[str]         =			_get_library_root_logger()
   library_root_logger.setLevel(_get_default_logging_level()			)
def 							UpperCAmelCase_  (						):
   lowercase_      :str         =			_get_library_root_logger()
   library_root_logger.setLevel(logging.NOTSET			)
def 							UpperCAmelCase_  (						__lowerCamelCase : Optional[str] = None			):
   if name is None:
      lowercase_      :Optional[Any]         =			_get_library_name()
   return logging.getLogger(SCREAMING_SNAKE_CASE_			)
def 							UpperCAmelCase_  (						):
   return _get_library_root_logger().getEffectiveLevel()
def 							UpperCAmelCase_  (						__lowerCamelCase : int			):
   _get_library_root_logger().setLevel(SCREAMING_SNAKE_CASE_			)
def 							UpperCAmelCase_  (						):
   return set_verbosity(SCREAMING_SNAKE_CASE_			)
def 							UpperCAmelCase_  (						):
   return set_verbosity(SCREAMING_SNAKE_CASE_			)
def 							UpperCAmelCase_  (						):
   return set_verbosity(SCREAMING_SNAKE_CASE_			)
def 							UpperCAmelCase_  (						):
   return set_verbosity(SCREAMING_SNAKE_CASE_			)
def 							UpperCAmelCase_  (						):
   lowercase_      :int         =			False
def 							UpperCAmelCase_  (						):
   lowercase_      :int         =			True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()
class 				a_       :





     def __init__(			self		: Tuple     ,				*lowercase		: Optional[Any]     ,				**lowercase		: Tuple						):  # pylint: disable=unused-argument





        """simple docstring"""




        lowercase_      :List[str]         =			args[0] if args else None





     def __iter__(			self		: Tuple						):





        """simple docstring"""




        return iter(self._iterator						)





     def __getattr__(			self		: Tuple     ,				lowercase		: int						):





        """simple docstring"""




        def empty_fn(*lowercase		: Optional[int]     ,				**lowercase		: Union[str, Any]						):  # pylint: disable=unused-argument
           return

        return empty_fn





     def __enter__(			self		: Optional[Any]						):





        """simple docstring"""




        return self







     def __exit__(			self		: Dict     ,				lowercase		: Union[str, Any]     ,				lowercase		: Optional[int]     ,				lowercase		: Union[str, Any]						):





        """simple docstring"""




        return







lowerCAmelCase :					str 							=True
class 				a_       :





     def __call__(			self		: Any     ,				*lowercase		: Union[str, Any]     ,				lowercase		: Optional[int]=False     ,				**lowercase		: str						):





        """simple docstring"""




        if _tqdm_active and not disable:
           return tqdm_lib.tqdm(*_A     ,				**_A						)
        else:
           return EmptyTqdm(*_A     ,				**_A						)





     def 							lowercase__				(			self		: Optional[Any]     ,				*lowercase		: List[Any]     ,				**lowercase		: int						):





        """simple docstring"""




        lowercase_      :int         =			None
        if _tqdm_active:
           return tqdm_lib.tqdm.set_lock(*_A     ,				**_A						)







     def 							lowercase__				(			self		: str						):





        """simple docstring"""




        if _tqdm_active:
           return tqdm_lib.tqdm.get_lock()







lowerCAmelCase :					Optional[Any] 							=_tqdm_cls()
def 							UpperCAmelCase_  (						):
   global _tqdm_active
   return bool(_tqdm_active			)
def 							UpperCAmelCase_  (						):
   global _tqdm_active
   lowercase_      :Union[str, Any]         =			True


def 							UpperCAmelCase_  (						):
   global _tqdm_active
   lowercase_      :List[str]         =			False









'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase :					Optional[int] 							={'''configuration_wavlm''': ['''WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''WavLMConfig''']}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase :					Optional[Any] 							=[
     '''WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''WavLMForAudioFrameClassification''',
     '''WavLMForCTC''',
     '''WavLMForSequenceClassification''',
     '''WavLMForXVector''',
     '''WavLMModel''',
     '''WavLMPreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_wavlm import (
      WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      WavLMForAudioFrameClassification,
      WavLMForCTC,
      WavLMForSequenceClassification,
      WavLMForXVector,
      WavLMModel,
      WavLMPreTrainedModel,
  )

else:
 import sys

 lowerCAmelCase :					Union[str, Any] 							=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


