

"""simple docstring"""




from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching

def 						A							(  ):




			'''simple docstring'''


			import os as original_os
			from os import path as original_path
			from os import rename as original_rename
			from os.path import dirname as original_dirname
			from os.path import join as original_join

			assert _test_patching.os is original_os
			assert _test_patching.path is original_path
			assert _test_patching.join is original_join

			assert _test_patching.renamed_os is original_os
			assert _test_patching.renamed_path is original_path
			assert _test_patching.renamed_join is original_join

			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_mock__"""
			with patch_submodule(_test_patching		,					"""os.path.join"""		,					snake_case__     ):
						# Every way to access os.path.join must be patched, and the rest must stay untouched

						# check os.path.join
						assert isinstance(_test_patching.os		,					_PatchedModuleObj     )
						assert isinstance(_test_patching.os.path		,					_PatchedModuleObj     )
						assert _test_patching.os.path.join is mock

						# check path.join
						assert isinstance(_test_patching.path		,					_PatchedModuleObj     )
						assert _test_patching.path.join is mock

						# check join
						assert _test_patching.join is mock

						# check that the other attributes are untouched
						assert _test_patching.os.rename is original_rename
						assert _test_patching.path.dirname is original_dirname
						assert _test_patching.os.path.dirname is original_dirname

						# Even renamed modules or objects must be patched

						# check renamed_os.path.join
						assert isinstance(_test_patching.renamed_os		,					_PatchedModuleObj     )
						assert isinstance(_test_patching.renamed_os.path		,					_PatchedModuleObj     )
						assert _test_patching.renamed_os.path.join is mock

						# check renamed_path.join
						assert isinstance(_test_patching.renamed_path		,					_PatchedModuleObj     )
						assert _test_patching.renamed_path.join is mock

						# check renamed_join
						assert _test_patching.renamed_join is mock

						# check that the other attributes are untouched
						assert _test_patching.renamed_os.rename is original_rename
						assert _test_patching.renamed_path.dirname is original_dirname
						assert _test_patching.renamed_os.path.dirname is original_dirname

			# check that everthing is back to normal when the patch is over

			assert _test_patching.os is original_os
			assert _test_patching.path is original_path
			assert _test_patching.join is original_join

			assert _test_patching.renamed_os is original_os
			assert _test_patching.renamed_path is original_path
			assert _test_patching.renamed_join is original_join

def 						A							(  ):




			'''simple docstring'''


			assert _test_patching.open is open

			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_builtin_mock__"""
			# _test_patching has "open" in its globals
			assert _test_patching.open is open
			with patch_submodule(_test_patching		,					"""open"""		,					snake_case__     ):
						assert _test_patching.open is mock

			# check that everthing is back to normal when the patch is over

			assert _test_patching.open is open

def 						A							(  ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_missing_mock__"""
			with patch_submodule(_test_patching		,					"""pandas.read_csv"""		,					snake_case__     ):
						pass

def 						A							(  ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_missing_builtin_mock__"""
			# _test_patching doesn't have "len" in its globals
			assert getattr(_test_patching		,					"""len"""		,					snake_case__     ) is None
			with patch_submodule(_test_patching		,					"""len"""		,					snake_case__     ):
						assert _test_patching.len is mock
			assert _test_patching.len is len

def 						A							(  ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_start_and_stop_mock__"""
			SCREAMING_SNAKE_CASE__										=   patch_submodule(_test_patching		,					"""open"""		,					snake_case__     )
			assert _test_patching.open is open
			patch.start()
			assert _test_patching.open is mock
			patch.stop()
			assert _test_patching.open is open

def 						A							(  ):




			'''simple docstring'''


			from os import rename as original_rename
			from os.path import dirname as original_dirname
			from os.path import join as original_join

			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_successive_join__"""
			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_successive_dirname__"""
			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_successive_rename__"""
			assert _test_patching.os.path.join is original_join
			assert _test_patching.os.path.dirname is original_dirname
			assert _test_patching.os.rename is original_rename

			with patch_submodule(_test_patching		,					"""os.path.join"""		,					snake_case__     ):
						with patch_submodule(_test_patching		,					"""os.rename"""		,					snake_case__     ):
									with patch_submodule(_test_patching		,					"""os.path.dirname"""		,					snake_case__     ):
												assert _test_patching.os.path.join is mock_join
												assert _test_patching.os.path.dirname is mock_dirname
												assert _test_patching.os.rename is mock_rename

    # try another order
			with patch_submodule(_test_patching		,					"""os.rename"""		,					snake_case__     ):
						with patch_submodule(_test_patching		,					"""os.path.join"""		,					snake_case__     ):
									with patch_submodule(_test_patching		,					"""os.path.dirname"""		,					snake_case__     ):
												assert _test_patching.os.path.join is mock_join
												assert _test_patching.os.path.dirname is mock_dirname
												assert _test_patching.os.rename is mock_rename

			assert _test_patching.os.path.join is original_join
			assert _test_patching.os.path.dirname is original_dirname
			assert _test_patching.os.rename is original_rename




def 						A							(  ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__										=   """__test_patch_submodule_doesnt_exist_mock__"""
			with patch_submodule(_test_patching		,					"""__module_that_doesn_exist__.__attribute_that_doesn_exist__"""		,					snake_case__     ):
						pass
			with patch_submodule(_test_patching		,					"""os.__attribute_that_doesn_exist__"""		,					snake_case__     ):
						pass





"""simple docstring"""




from typing import List

from .keymap import KEYMAP, get_character

def 						A							(  snake_case__     ):




			'''simple docstring'''


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

			return decorator

def 						A							(  *snake_case__     ):




			'''simple docstring'''


			def decorator(snake_case__     ):
						SCREAMING_SNAKE_CASE__										=   getattr(snake_case__		,					"""handle_key"""		,					[]     )
						handle += keys
						setattr(snake_case__		,					"""handle_key"""		,					snake_case__     )
						return func

			return decorator





class  lowerCamelCase    (A__      ):

			def __new__(       cls					:    Dict     ,					__UpperCAmelCase					:    Tuple     ,					__UpperCAmelCase					:    Any     ,					__UpperCAmelCase					:    Optional[Any]							) ->     List[str]:
						SCREAMING_SNAKE_CASE__										=   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():
									SCREAMING_SNAKE_CASE__										=   getattr(__UpperCAmelCase     ,					"""handle_key"""     ,					[]							)
									for key in handled_keys:
												SCREAMING_SNAKE_CASE__										=   value
						return new_cls





			@staticmethod
			def        SCREAMING_SNAKE_CASE					(       cls					:    Tuple							) ->     Dict:
						SCREAMING_SNAKE_CASE__										=   get_character()
						if char != KEYMAP["undefined"]:
									SCREAMING_SNAKE_CASE__										=   ord(__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   cls.key_handler.get(__UpperCAmelCase							)
						if handler:
									SCREAMING_SNAKE_CASE__										=   char
									return handler(cls							)
						else:
									return None

def 						A							(  cls     ):




			'''simple docstring'''


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


