





from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching
def      A__       (    )  ->  Dict:






   """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

   _UpperCAmelCase           =   '''__test_patch_submodule_mock__'''
   with patch_submodule(_test_patching				,	'''os.path.join'''				,	SCREAMING_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__       (    )  ->  Dict:






   """simple docstring"""







   assert _test_patching.open is open

   _UpperCAmelCase           =   '''__test_patch_submodule_builtin_mock__'''
   # _test_patching has "open" in its globals
   assert _test_patching.open is open
   with patch_submodule(_test_patching				,	'''open'''				,	SCREAMING_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__       (    )  ->  List[Any]:






   """simple docstring"""







   _UpperCAmelCase           =   '''__test_patch_submodule_missing_mock__'''
   with patch_submodule(_test_patching				,	'''pandas.read_csv'''				,	SCREAMING_SNAKE_CASE_						):
      pass
def      A__       (    )  ->  List[Any]:






   """simple docstring"""







   _UpperCAmelCase           =   '''__test_patch_submodule_missing_builtin_mock__'''
   # _test_patching doesn't have "len" in its globals
   assert getattr(_test_patching				,	'''len'''				,	SCREAMING_SNAKE_CASE_						) is None
   with patch_submodule(_test_patching				,	'''len'''				,	SCREAMING_SNAKE_CASE_						):
      assert _test_patching.len is mock
   assert _test_patching.len is len
def      A__       (    )  ->  Tuple:






   """simple docstring"""







   _UpperCAmelCase           =   '''__test_patch_submodule_start_and_stop_mock__'''
   _UpperCAmelCase           =   patch_submodule(_test_patching				,	'''open'''				,	SCREAMING_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__       (    )  ->  Union[str, Any]:






   """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

   _UpperCAmelCase           =   '''__test_patch_submodule_successive_join__'''
   _UpperCAmelCase           =   '''__test_patch_submodule_successive_dirname__'''
   _UpperCAmelCase           =   '''__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'''				,	SCREAMING_SNAKE_CASE_						):
      with patch_submodule(_test_patching				,	'''os.rename'''				,	SCREAMING_SNAKE_CASE_						):
         with patch_submodule(_test_patching				,	'''os.path.dirname'''				,	SCREAMING_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'''				,	SCREAMING_SNAKE_CASE_						):
      with patch_submodule(_test_patching				,	'''os.path.join'''				,	SCREAMING_SNAKE_CASE_						):
         with patch_submodule(_test_patching				,	'''os.path.dirname'''				,	SCREAMING_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__       (    )  ->  List[Any]:






   """simple docstring"""







   _UpperCAmelCase           =   '''__test_patch_submodule_doesnt_exist_mock__'''
   with patch_submodule(_test_patching				,	'''__module_that_doesn_exist__.__attribute_that_doesn_exist__'''				,	SCREAMING_SNAKE_CASE_						):
      pass
   with patch_submodule(_test_patching				,	'''os.__attribute_that_doesn_exist__'''				,	SCREAMING_SNAKE_CASE_						):
      pass





"""simple docstring"""






from __future__ import annotations







def 	_snake_case     (							lowercase__						):
				_lowerCamelCase	:     int       =       len(lowercase__						)
				# We need to create solution object to save path.
				_lowerCamelCase	:     Tuple       =       [[0 for _ in range(lowercase__						)] for _ in range(lowercase__						)]
				_lowerCamelCase	:     Optional[Any]       =       run_maze(lowercase__				,       0				,       0				,       lowercase__						)
				if solved:
								print('\n'.join(str(lowercase__						) for row in solutions						)						)
				else:
								print('No solution exists!'						)
				return solved







def 	_snake_case     (							lowercase__				,       lowercase__				,       lowercase__				,       lowercase__						):
				_lowerCamelCase	:     Optional[int]       =       len(lowercase__						)
				# Final check point.
				if i == j == (size - 1):
								_lowerCamelCase	:     Optional[Any]       =       1
								return True

				_lowerCamelCase	:     List[str]       =       (not i < 0) and (not j < 0)  # Check lower bounds
				_lowerCamelCase	:     List[str]       =       (i < size) and (j < size)  # Check upper bounds

				if lower_flag and upper_flag:
								# check for already visited and block points.
								_lowerCamelCase	:     List[Any]       =       (not solutions[i][j]) and (not maze[i][j])
								if block_flag:
												# check visited
												_lowerCamelCase	:     Union[str, Any]       =       1

												# check for directions
												if (
												    run_maze(lowercase__				,       i + 1				,       lowercase__				,       lowercase__						)
												    or run_maze(lowercase__				,       lowercase__				,       j + 1				,       lowercase__						)
												    or run_maze(lowercase__				,       i - 1				,       lowercase__				,       lowercase__						)
												    or run_maze(lowercase__				,       lowercase__				,       j - 1				,       lowercase__						)
												):
																return True

												_lowerCamelCase	:     Dict       =       0
												return False
				return False


if __name__ == "__main__":
			import doctest

			doctest.testmod()