





'''simple docstring'''




from typing import List

from .keymap import KEYMAP, get_character
def 	UpperCAmelCase_							(					__lowercase							:      str       )		->       Any:


     '''simple docstring'''



     def decorator(__lowercase							:      List[Any]       ):
          _UpperCAmelCase     							=   getattr(__SCREAMING_SNAKE_CASE			,     "handle_key"			,     []       )
          handle += [key]
          setattr(__SCREAMING_SNAKE_CASE			,     "handle_key"			,     __SCREAMING_SNAKE_CASE       )
          return func

     return decorator
def 	UpperCAmelCase_							(					*__lowercase							:      List[str]       )		->       int:


     '''simple docstring'''



     def decorator(__lowercase							:      Any       ):
          _UpperCAmelCase     							=   getattr(__SCREAMING_SNAKE_CASE			,     "handle_key"			,     []       )
          handle += keys
          setattr(__SCREAMING_SNAKE_CASE			,     "handle_key"			,     __SCREAMING_SNAKE_CASE       )
          return func

     return decorator







class   A_	(  lowercase_			):




 def __new__(					cls       :    List[Any]	,			snake_case_       :    Tuple	,			snake_case_       :    Optional[Any]	,			snake_case_       :    Union[str, Any]    ):
      _UpperCAmelCase     							=   super().__new__(cls	,			__UpperCamelCase	,			__UpperCamelCase	,			__UpperCamelCase    )
      if not hasattr(__UpperCamelCase	,			"key_handler"    ):
           setattr(__UpperCamelCase	,			"key_handler"	,			{}    )
      setattr(__UpperCamelCase	,			"handle_input"	,			KeyHandler.handle_input    )

      for value in attrs.values():
           _UpperCAmelCase     							=   getattr(__UpperCamelCase	,			"handle_key"	,			[]    )
           for key in handled_keys:
                _UpperCAmelCase     							=   value
      return new_cls




 @staticmethod
 def      lowercase	(					cls       :    Optional[Any]    ):
      _UpperCAmelCase     							=   get_character()
      if char != KEYMAP["undefined"]:
           _UpperCAmelCase     							=   ord(__UpperCamelCase    )
      _UpperCAmelCase     							=   cls.key_handler.get(__UpperCamelCase    )
      if handler:
           _UpperCAmelCase     							=   char
           return handler(cls    )
      else:
           return None





def 	UpperCAmelCase_							(					cls							:      List[str]       )		->       int:


     '''simple docstring'''



     return KeyHandler(cls.__name__			,     cls.__bases__			,     cls.__dict__.copy()       )





"""simple docstring"""







import sys

from .dependency_versions_table import deps
from .utils.versions import require_version, require_version_core


# define which module versions we always want to check at run time
# (usually the ones defined in `install_requires` in setup.py)
#
# order specific notes:
# - tqdm must be checked before tokenizers

__SCREAMING_SNAKE_CASE    	="python tqdm regex requests packaging filelock numpy tokenizers".split()
if sys.version_info < (3, 7):
       pkgs_to_check_at_runtime.append("dataclasses")
if sys.version_info < (3, 8):
       pkgs_to_check_at_runtime.append("importlib_metadata")

for pkg in pkgs_to_check_at_runtime:
       if pkg in deps:
              if pkg == "tokenizers":
                     # must be loaded here, or else tqdm check may fail
                     from .utils import is_tokenizers_available

                     if not is_tokenizers_available():
                            continue  # not required, check version only if installed

              require_version_core(deps[pkg])
       else:
              raise ValueError(F"can't find {pkg} in {deps.keys()}, check dependency_versions_table.py")



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     int     ,			__SCREAMING_SNAKE_CASE							:     Union[str, Any]=None      ):
     require_version(deps[pkg]     ,			__SCREAMING_SNAKE_CASE      )

