





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

 UpperCamelCase      :   List[Any]			      =  "__test_patch_submodule_mock__"
 with patch_submodule(_test_patching				,  "os.path.join"				,  _lowerCAmelCase	):
  # 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_							(	)		->					int:
 assert _test_patching.open is open

 UpperCamelCase      :   int			      =  "__test_patch_submodule_builtin_mock__"
 # _test_patching has "open" in its globals
 assert _test_patching.open is open
 with patch_submodule(_test_patching				,  "open"				,  _lowerCAmelCase	):
  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]:
 # pandas.read_csv is not present in _test_patching
 UpperCamelCase      :   str			      =  "__test_patch_submodule_missing_mock__"
 with patch_submodule(_test_patching				,  "pandas.read_csv"				,  _lowerCAmelCase	):
  pass



def 						A_							(	)		->					Dict:
 # builtin should always be mocked even if they're not in the globals
 # in case they're loaded at one point
 UpperCamelCase      :   int			      =  "__test_patch_submodule_missing_builtin_mock__"
 # _test_patching doesn't have "len" in its globals
 assert getattr(_test_patching				,  "len"				,  _lowerCAmelCase	) is None
 with patch_submodule(_test_patching				,  "len"				,  _lowerCAmelCase	):
  assert _test_patching.len is mock
 assert _test_patching.len is len



def 						A_							(	)		->					List[Any]:
 UpperCamelCase      :   int			      =  "__test_patch_submodule_start_and_stop_mock__"
 UpperCamelCase      :   Optional[int]			      =  patch_submodule(_test_patching				,  "open"				,  _lowerCAmelCase	)
 assert _test_patching.open is open
 patch.start()
 assert _test_patching.open is mock
 patch.stop()
 assert _test_patching.open is open



def 						A_							(	)		->					int:
 from os import rename as original_rename
 from os.path import dirname as original_dirname
 from os.path import join as original_join

 UpperCamelCase      :   List[str]			      =  "__test_patch_submodule_successive_join__"
 UpperCamelCase      :   Tuple			      =  "__test_patch_submodule_successive_dirname__"
 UpperCamelCase      :   Tuple			      =  "__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"				,  _lowerCAmelCase	):
  with patch_submodule(_test_patching				,  "os.rename"				,  _lowerCAmelCase	):
   with patch_submodule(_test_patching				,  "os.path.dirname"				,  _lowerCAmelCase	):
    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"				,  _lowerCAmelCase	):
  with patch_submodule(_test_patching				,  "os.path.join"				,  _lowerCAmelCase	):
   with patch_submodule(_test_patching				,  "os.path.dirname"				,  _lowerCAmelCase	):
    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_							(	)		->					Tuple:
 UpperCamelCase      :   str			      =  "__test_patch_submodule_doesnt_exist_mock__"
 with patch_submodule(_test_patching				,  "__module_that_doesn_exist__.__attribute_that_doesn_exist__"				,  _lowerCAmelCase	):
  pass
 with patch_submodule(_test_patching				,  "os.__attribute_that_doesn_exist__"				,  _lowerCAmelCase	):
  pass







__lowerCamelCase			:	Any					    =	9.8_0_6_6_5



def 						A_							(	_lowerCAmelCase				,  _lowerCAmelCase				,  _lowerCAmelCase = g	)		->					float:

 if fluid_density <= 0:
  raise ValueError("Impossible fluid density"	)
 if volume < 0:
  raise ValueError("Impossible Object volume"	)
 if gravity <= 0:
  raise ValueError("Impossible Gravity"	)

 return fluid_density * gravity * volume


if __name__ == "__main__":
    import doctest

    # run doctest
    doctest.testmod()
