


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_     (  )  ->				List[str]:
       lowercase__:   Union[str, Any]  			=   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_     (  )  ->				str:
       return __name__.split('.'     )[0]




def    snake_case_     (  )  ->				logging.Logger:
       return logging.getLogger(_get_library_name()     )




def    snake_case_     (  )  ->				None:
       # Apply our default configuration to the library root logger.
       lowercase__:   Any  			=   _get_library_root_logger()
       library_root_logger.setLevel(_get_default_logging_level()     )




def    snake_case_     (  )  ->				None:
       lowercase__:   List[Any]  			=   _get_library_root_logger()
       library_root_logger.setLevel(logging.NOTSET     )




def    snake_case_     (  snake_case = None     )  ->				logging.Logger:
       if name is None:
              lowercase__:   List[str]  			=   _get_library_name()
       return logging.getLogger(snake_case     )




def    snake_case_     (  )  ->				int:
       return _get_library_root_logger().getEffectiveLevel()




def    snake_case_     (  snake_case     )  ->				None:
       _get_library_root_logger().setLevel(snake_case     )




def    snake_case_     (  )  ->				Tuple:
       return set_verbosity(snake_case     )




def    snake_case_     (  )  ->				Optional[int]:
       return set_verbosity(snake_case     )




def    snake_case_     (  )  ->				Any:
       return set_verbosity(snake_case     )




def    snake_case_     (  )  ->				Optional[int]:
       return set_verbosity(snake_case     )




def    snake_case_     (  )  ->				None:
       lowercase__:   List[str]  			=   False




def    snake_case_     (  )  ->				None:
       lowercase__:   List[Any]  			=   True


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





class   __a			:
 def __init__(   self				, *lowerCAmelCase__				, **lowerCAmelCase__ )					->				List[Any]:  # pylint: disable=unused-argument




        '''simple docstring'''
        lowercase__:   Dict  			=   args[0] if args else None
 def __iter__(   self )					->				List[Any]:




        '''simple docstring'''
        return iter(self._iterator )
 def __getattr__(   self				, lowerCAmelCase__ )					->				Optional[Any]:




        '''simple docstring'''

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

        return empty_fn
 def __enter__(   self )					->				Union[str, Any]:




        '''simple docstring'''
        return self
 def __exit__(   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__ )					->				Tuple:




        '''simple docstring'''
        return





__lowerCAmelCase		       =							True





class   __a			:
 def __call__(   self				, *lowerCAmelCase__				, lowerCAmelCase__=False				, **lowerCAmelCase__ )					->				List[Any]:




        '''simple docstring'''
        if _tqdm_active and not disable:
               return tqdm_lib.tqdm(*lowerCAmelCase__				, **lowerCAmelCase__ )
        else:
               return EmptyTqdm(*lowerCAmelCase__				, **lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self				, *lowerCAmelCase__				, **lowerCAmelCase__ )					->				Union[str, Any]:




        '''simple docstring'''
        lowercase__:   Optional[Any]  			=   None
        if _tqdm_active:
               return tqdm_lib.tqdm.set_lock(*lowerCAmelCase__				, **lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Dict:




        '''simple docstring'''
        if _tqdm_active:
               return tqdm_lib.tqdm.get_lock()





__lowerCAmelCase		       =							_tqdm_cls()




def    snake_case_     (  )  ->				bool:
       global _tqdm_active
       return bool(_tqdm_active     )




def    snake_case_     (  )  ->				List[Any]:
       global _tqdm_active
       lowercase__:   List[str]  			=   True




def    snake_case_     (  )  ->				Any:
       global _tqdm_active
       lowercase__:   List[str]  			=   False






from __future__ import annotations




def    snake_case_     (  snake_case			,							snake_case     )  ->				list[int]:
       lowercase__:   List[str]  			=   0
       lowercase__:   Dict  			=   len(snake_case     ) - 1

       while i < j:
              if nums[i] + nums[j] == target:
                     return [i, j]
              elif nums[i] + nums[j] < target:
                     lowercase__:   Dict  			=   i + 1
              else:
                     lowercase__:   List[Any]  			=   j - 1

       return []


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F'''{two_pointer([2, 7, 11, 15], 9) = }''')


