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       =		{
    "debug": logging.DEBUG,
    "info": logging.INFO,
    "warning": logging.WARNING,
    "error": logging.ERROR,
    "critical": logging.CRITICAL,
}

_lowerCAmelCase       =		logging.WARNING
def 					_snake_case	(  ):
					_UpperCamelCase			     =     os.getenv('''DATASETS_VERBOSITY'''  ,     __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 					_snake_case	(  ):
					return __name__.split('''.'''						)[0]
def 					_snake_case	(  ):
					return logging.getLogger(_get_library_name()						)
def 					_snake_case	(  ):
					# Apply our default configuration to the library root logger.
					_UpperCamelCase			     =     _get_library_root_logger()
					library_root_logger.setLevel(_get_default_logging_level()						)
def 					_snake_case	(  ):
					_UpperCamelCase			     =     _get_library_root_logger()
					library_root_logger.setLevel(logging.NOTSET						)
def 					_snake_case	(  __snake_case = None						):
					if name is None:
										_UpperCamelCase			     =     _get_library_name()
					return logging.getLogger(__snake_case						)
def 					_snake_case	(  ):
					return _get_library_root_logger().getEffectiveLevel()
def 					_snake_case	(  __snake_case						):
					_get_library_root_logger().setLevel(__snake_case						)
def 					_snake_case	(  ):
					return set_verbosity(__snake_case						)
def 					_snake_case	(  ):
					return set_verbosity(__snake_case						)
def 					_snake_case	(  ):
					return set_verbosity(__snake_case						)
def 					_snake_case	(  ):
					return set_verbosity(__snake_case						)
def 					_snake_case	(  ):
					_UpperCamelCase			     =     False
def 					_snake_case	(  ):
					_UpperCamelCase			     =     True


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







							def __init__(   self      :     Any ,			*_A      :     Union[str, Any] ,			**_A      :     str		):  # pylint: disable=unused-argument
												_UpperCamelCase			     =     args[0] if args else None







							def __iter__(   self      :     Optional[Any]		):
												return iter(self._iterator		)







							def __getattr__(   self      :     Any ,			_A      :     Optional[int]		):

												def empty_fn(*_A      :     List[Any] ,			**_A      :     List[str]		):  # pylint: disable=unused-argument
																	return

												return empty_fn







							def __enter__(   self      :     str		):
												return self







							def __exit__(   self      :     str ,			_A      :     List[str] ,			_A      :     Dict ,			_A      :     str		):
												return




_lowerCAmelCase       =		True
class     lowerCAmelCase_     :







							def __call__(   self      :     int ,			*_A      :     Union[str, Any] ,			_A      :     Optional[int]=False ,			**_A      :     Dict		):
												if _tqdm_active and not disable:
																	return tqdm_lib.tqdm(*_A ,			**_A		)
												else:
																	return EmptyTqdm(*_A ,			**_A		)







							def  UpperCamelCase_						(   self      :     int ,			*_A      :     str ,			**_A      :     Optional[int]		):
												_UpperCamelCase			     =     None
												if _tqdm_active:
																	return tqdm_lib.tqdm.set_lock(*_A ,			**_A		)







							def  UpperCamelCase_						(   self      :     Union[str, Any]		):
												if _tqdm_active:
																	return tqdm_lib.tqdm.get_lock()




_lowerCAmelCase       =		_tqdm_cls()
def 					_snake_case	(  ):
					global _tqdm_active
					return bool(_tqdm_active						)
def 					_snake_case	(  ):
					global _tqdm_active
					_UpperCamelCase			     =     True







def 					_snake_case	(  ):
					global _tqdm_active
					_UpperCamelCase			     =     False





'''simple docstring'''
def A__       (	UpperCAmelCase_    ,    UpperCAmelCase_				):
						return base * power(UpperCAmelCase_    ,    (exponent - 1)				) if exponent else 1


if __name__ == "__main__":
					print('Raise base to the power of exponent using recursion...')
					snake_case_					:      int    			=    int(input('Enter the base: ').strip())
					snake_case_					:      Optional[int]    			=    int(input('Enter the exponent: ').strip())
					snake_case_					:      Optional[int]    			=    power(base, abs(exponent))
					if exponent < 0:  # power() does not properly deal w/ negative exponents
										snake_case_					:      List[Any]    			=    1 / result
					print(F"""{base} to the power of {exponent} is {result}""")


