

"""simple docstring"""



from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching





def  _snake_case     (    ):
     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

     A__										=  """__test_patch_submodule_mock__"""
     with patch_submodule(_test_patching					,   """os.path.join"""					,   UpperCAmelCase_			):
          # 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  _snake_case     (    ):
     assert _test_patching.open is open

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





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





def  _snake_case     (    ):
     A__										=  """__test_patch_submodule_start_and_stop_mock__"""
     A__										=  patch_submodule(_test_patching					,   """open"""					,   UpperCAmelCase_			)
     assert _test_patching.open is open
     patch.start()
     assert _test_patching.open is mock
     patch.stop()
     assert _test_patching.open is open





def  _snake_case     (    ):
     from os import rename as original_rename
     from os.path import dirname as original_dirname
     from os.path import join as original_join

     A__										=  """__test_patch_submodule_successive_join__"""
     A__										=  """__test_patch_submodule_successive_dirname__"""
     A__										=  """__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"""					,   UpperCAmelCase_			):
          with patch_submodule(_test_patching					,   """os.rename"""					,   UpperCAmelCase_			):
               with patch_submodule(_test_patching					,   """os.path.dirname"""					,   UpperCAmelCase_			):
                    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"""					,   UpperCAmelCase_			):
          with patch_submodule(_test_patching					,   """os.path.join"""					,   UpperCAmelCase_			):
               with patch_submodule(_test_patching					,   """os.path.dirname"""					,   UpperCAmelCase_			):
                    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  _snake_case     (    ):
     A__										=  """__test_patch_submodule_doesnt_exist_mock__"""
     with patch_submodule(_test_patching					,   """__module_that_doesn_exist__.__attribute_that_doesn_exist__"""					,   UpperCAmelCase_			):
          pass
     with patch_submodule(_test_patching					,   """os.__attribute_that_doesn_exist__"""					,   UpperCAmelCase_			):
          pass









"""simple docstring"""



SCREAMING_SNAKE_CASE_					:	str							  =						'0.21.0'

from .accelerator import Accelerator
from .big_modeling import (
    cpu_offload,
    cpu_offload_with_hook,
    disk_offload,
    dispatch_model,
    init_empty_weights,
    init_on_device,
    load_checkpoint_and_dispatch,
)
from .data_loader import skip_first_batches
from .launchers import debug_launcher, notebook_launcher
from .state import PartialState
from .utils import (
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    FullyShardedDataParallelPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    find_executable_batch_size,
    infer_auto_device_map,
    is_rich_available,
    load_checkpoint_in_model,
    synchronize_rng_states,
)


if is_rich_available():
 from .utils import rich






