





from typing import List

from .keymap import KEYMAP, get_character







def       UpperCAmelCase							(     _lowerCamelCase      :  str     ):





						'''simple docstring'''


						def decorator(_lowerCamelCase      :  Dict     ):
												SCREAMING_SNAKE_CASE__     :				Tuple   =					getattr(_lowerCamelCase			,   "handle_key"			,   []     )
												handle += [key]
												setattr(_lowerCamelCase			,   "handle_key"			,   _lowerCamelCase     )
												return func

						return decorator







def       UpperCAmelCase							(     *_lowerCamelCase      :  List[str]     ):





						'''simple docstring'''


						def decorator(_lowerCamelCase      :  List[str]     ):
												SCREAMING_SNAKE_CASE__     :				Optional[int]   =					getattr(_lowerCamelCase			,   "handle_key"			,   []     )
												handle += keys
												setattr(_lowerCamelCase			,   "handle_key"			,   _lowerCamelCase     )
												return func

						return decorator



class    _a     (				lowercase__							):






							"""simple docstring"""

							def __new__(      cls				:     Any							,	a				:     Any							,	a				:     Any							,	a				:     Optional[Any]    )	->Dict:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					super().__new__(cls							,	a							,	a							,	a    )
													if not hasattr(a							,	"key_handler"    ):
																			setattr(a							,	"key_handler"							,	{}    )
													setattr(a							,	"handle_input"							,	KeyHandler.handle_input    )

													for value in attrs.values():
																			SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					getattr(a							,	"handle_key"							,	[]    )
																			for key in handled_keys:
																									SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					value
													return new_cls






							@staticmethod
							def      A_  (      cls				:     Dict    )	->Optional[int]:
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					get_character()
													if char != KEYMAP["undefined"]:
																			SCREAMING_SNAKE_CASE__     :				Dict   =					ord(a    )
													SCREAMING_SNAKE_CASE__     :				Tuple   =					cls.key_handler.get(a    )
													if handler:
																			SCREAMING_SNAKE_CASE__     :				int   =					char
																			return handler(cls    )
													else:
																			return None







def       UpperCAmelCase							(     cls      :  Union[str, Any]     ):





						'''simple docstring'''


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






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

__lowercase       :List[Any]       =  "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       UpperCAmelCase							(     _lowerCamelCase      :  Optional[Any]			,   _lowerCamelCase      :  Optional[Any]=None     ):





						'''simple docstring'''


						require_version(deps[pkg]			,   _lowerCamelCase     )