


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


__UpperCamelCase     		=							{
    'debug': logging.DEBUG,
    'info': logging.INFO,
    'warning': logging.WARNING,
    'error': logging.ERROR,
    'critical': logging.CRITICAL,
}

__UpperCamelCase     		=							logging.WARNING
def 							UpperCamelCase_(					)->		Optional[Any]:
			UpperCamelCase__       =							os.getenv("DATASETS_VERBOSITY"					,  _A	)
			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_(					)->		str:
			return __name__.split("."	)[0]
def 							UpperCamelCase_(					)->		logging.Logger:
			return logging.getLogger(_get_library_name()	)
def 							UpperCamelCase_(					)->		None:
			# Apply our default configuration to the library root logger.
			UpperCamelCase__       =							_get_library_root_logger()
			library_root_logger.setLevel(_get_default_logging_level()	)
def 							UpperCamelCase_(					)->		None:
			UpperCamelCase__       =							_get_library_root_logger()
			library_root_logger.setLevel(logging.NOTSET	)
def 							UpperCamelCase_(					_A :Optional[str] = None	)->		logging.Logger:
			if name is None:
						UpperCamelCase__       =							_get_library_name()
			return logging.getLogger(_A	)
def 							UpperCamelCase_(					)->		int:
			return _get_library_root_logger().getEffectiveLevel()
def 							UpperCamelCase_(					_A :int	)->		None:
			_get_library_root_logger().setLevel(_A	)
def 							UpperCamelCase_(					)->		Dict:
			return set_verbosity(_A	)
def 							UpperCamelCase_(					)->		Union[str, Any]:
			return set_verbosity(_A	)
def 							UpperCamelCase_(					)->		List[Any]:
			return set_verbosity(_A	)
def 							UpperCamelCase_(					)->		List[str]:
			return set_verbosity(_A	)
def 							UpperCamelCase_(					)->		None:
			UpperCamelCase__       =							False
def 							UpperCamelCase_(					)->		None:
			UpperCamelCase__       =							True


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







class 							lowerCamelCase__						:






			"""simple docstring"""






			def __init__(				self   ,    *snake_case   ,    **snake_case  ):  # pylint: disable=unused-argument

						'''simple docstring'''


						UpperCamelCase__       =							args[0] if args else None




			def __iter__(				self  ):

						'''simple docstring'''


						return iter(self._iterator  )




			def __getattr__(				self   ,    snake_case  ):

						'''simple docstring'''


						def empty_fn(*snake_case   ,    **snake_case  ):  # pylint: disable=unused-argument
									return

						return empty_fn




			def __enter__(				self  ):

						'''simple docstring'''


						return self







			def __exit__(				self   ,    snake_case   ,    snake_case   ,    snake_case  ):

						'''simple docstring'''


						return



__UpperCamelCase     		=							True







class 							lowerCamelCase__						:






			"""simple docstring"""






			def __call__(				self   ,    *snake_case   ,    snake_case=False   ,    **snake_case  ):

						'''simple docstring'''


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




			def 					snake_case__					(				self   ,    *snake_case   ,    **snake_case  ):

						'''simple docstring'''


						UpperCamelCase__       =							None
						if _tqdm_active:
									return tqdm_lib.tqdm.set_lock(*snake_case   ,    **snake_case  )







			def 					snake_case__					(				self  ):

						'''simple docstring'''


						if _tqdm_active:
									return tqdm_lib.tqdm.get_lock()



__UpperCamelCase     		=							_tqdm_cls()
def 							UpperCamelCase_(					)->		bool:
			global _tqdm_active
			return bool(_tqdm_active	)
def 							UpperCamelCase_(					)->		Tuple:
			global _tqdm_active
			UpperCamelCase__       =							True







def 							UpperCamelCase_(					)->		Dict:
			global _tqdm_active
			UpperCamelCase__       =							False






from __future__ import annotations

import numpy as np
def 							UpperCamelCase_(					_A :list[float]	)->		Optional[Any]:
			return np.maximum(0					,  _A	)


if __name__ == "__main__":
						print(np.array(relu([-1, 0, 5])))  # --> [0, 0, 5]


