




"""simple docstring"""




from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching



def 					a__				(       )		->      Optional[Any]:
			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

			lowerCamelCase       =      """__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__				(       )		->      List[str]:
			assert _test_patching.open is open

			lowerCamelCase       =      """__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__				(       )		->      int:
			# pandas.read_csv is not present in _test_patching
			lowerCamelCase       =      """__test_patch_submodule_missing_mock__"""
			with patch_submodule(_test_patching ,				"""pandas.read_csv""" ,				snake_case__       ):
						pass



def 					a__				(       )		->      str:
			# builtin should always be mocked even if they're not in the globals
			# in case they're loaded at one point
			lowerCamelCase       =      """__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__				(       )		->      Any:
			lowerCamelCase       =      """__test_patch_submodule_start_and_stop_mock__"""
			lowerCamelCase       =      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__				(       )		->      str:
			from os import rename as original_rename
			from os.path import dirname as original_dirname
			from os.path import join as original_join

			lowerCamelCase       =      """__test_patch_submodule_successive_join__"""
			lowerCamelCase       =      """__test_patch_submodule_successive_dirname__"""
			lowerCamelCase       =      """__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__				(       )		->      str:
			lowerCamelCase       =      """__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 __future__ import annotations



def 					a__				(       snake_case__ ,				snake_case__ = None ,				snake_case__ = None       )		->      None:
			if start is None:
						lowerCamelCase       =      0

			if end is None:
						lowerCamelCase       =      len(snake_case__       ) - 1

			if start >= end:
						return

			lowerCamelCase       =      (start + end) // 2

			slowsort(snake_case__ ,				snake_case__ ,				snake_case__       )
			slowsort(snake_case__ ,				mid + 1 ,				snake_case__       )

			if sequence[end] < sequence[mid]:
						lowerCamelCase   ,     lowerCamelCase       =      sequence[mid], sequence[end]

			slowsort(snake_case__ ,				snake_case__ ,				end - 1       )


if __name__ == "__main__":
					from doctest import testmod

					testmod()



