




'''simple docstring'''




import os
import socket
from contextlib import contextmanager

import torch

from ..commands.config.default import write_basic_config  # noqa: F401
from ..state import PartialState
from .dataclasses import DistributedType
from .imports import is_deepspeed_available, is_tpu_available
from .transformer_engine import convert_model
from .versions import is_torch_version


if is_deepspeed_available():
     from deepspeed import DeepSpeedEngine

if is_tpu_available(check_device=False):
     import torch_xla.core.xla_model as xm





def      a_							(      __snake_case							:			List[str]   )							->						Optional[int]:



       """simple docstring"""
       if is_torch_version('''<'''   ,       '''2.0.0'''   ) or not hasattr(__snake_case   ,       '''_dynamo'''   ):
              return False
       return isinstance(__snake_case   ,       torch._dynamo.eval_frame.OptimizedModule   )





def      a_							(      __snake_case							:			Tuple   ,       __snake_case							:			bool = True   )							->						List[str]:



       """simple docstring"""
       lowerCamelCase_							=(torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)

       lowerCamelCase_							=is_compiled_module(__snake_case   )
       if is_compiled:
              lowerCamelCase_							=model
              lowerCamelCase_							=model._orig_mod

       if is_deepspeed_available():
              options += (DeepSpeedEngine,)

       while isinstance(__snake_case   ,       __snake_case   ):
              lowerCamelCase_							=model.module

       if not keep_fpaa_wrapper:
              lowerCamelCase_							=getattr(__snake_case   ,       '''forward'''   )
              lowerCamelCase_							=model.__dict__.pop('''_original_forward'''   ,       __snake_case   )
              if original_forward is not None:
                     while hasattr(__snake_case   ,       '''__wrapped__'''   ):
                            lowerCamelCase_							=forward.__wrapped__
                            if forward == original_forward:
                                   break
                     lowerCamelCase_							=forward
              if getattr(__snake_case   ,       '''_converted_to_transformer_engine'''   ,       __snake_case   ):
                     convert_model(__snake_case   ,       to_transformer_engine=__snake_case   )

       if is_compiled:
              lowerCamelCase_							=model
              lowerCamelCase_							=compiled_model

       return model





def      a_							(      )							->						Optional[Any]:



       """simple docstring"""
       PartialState().wait_for_everyone()





def      a_							(      __snake_case							:			Optional[int]   ,       __snake_case							:			Optional[Any]   )							->						List[str]:



       """simple docstring"""
       if PartialState().distributed_type == DistributedType.TPU:
              xm.save(__snake_case   ,       __snake_case   )
       elif PartialState().local_process_index == 0:
              torch.save(__snake_case   ,       __snake_case   )





@contextmanager
def      a_							(      **__snake_case							:			List[str]   )							->						Union[str, Any]:



       """simple docstring"""
       for key, value in kwargs.items():
              lowerCamelCase_							=str(__snake_case   )

       yield

       for key in kwargs:
              if key.upper() in os.environ:
                     del os.environ[key.upper()]





def      a_							(      __snake_case							:			Tuple   )							->						List[Any]:



       """simple docstring"""
       if not hasattr(__snake_case   ,       '''__qualname__'''   ) and not hasattr(__snake_case   ,       '''__name__'''   ):
              lowerCamelCase_							=getattr(__snake_case   ,       '''__class__'''   ,       __snake_case   )
       if hasattr(__snake_case   ,       '''__qualname__'''   ):
              return obj.__qualname__
       if hasattr(__snake_case   ,       '''__name__'''   ):
              return obj.__name__
       return str(__snake_case   )





def      a_							(      __snake_case							:			Dict   ,       __snake_case							:			Any   )							->						Tuple:



       """simple docstring"""
       for key, value in source.items():
              if isinstance(__snake_case   ,       __snake_case   ):
                     lowerCamelCase_							=destination.setdefault(__snake_case   ,       {}   )
                     merge_dicts(__snake_case   ,       __snake_case   )
              else:
                     lowerCamelCase_							=value

       return destination





def      a_							(      __snake_case							:			int = None   )							->						bool:



       """simple docstring"""
       if port is None:
              lowerCamelCase_							=2_9500
       with socket.socket(socket.AF_INET   ,       socket.SOCK_STREAM   ) as s:
              return s.connect_ex(('''localhost''', port)   ) == 0











from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






def lowerCamelCase__    (							)      ->				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

   __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 lowerCamelCase__    (							)      ->				Any:
   assert _test_patching.open is open

   __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 lowerCamelCase__    (							)      ->				List[str]:
   # pandas.read_csv is not present in _test_patching
   __snake_case							       =   '''__test_patch_submodule_missing_mock__'''
   with patch_submodule(_test_patching       ,      '''pandas.read_csv'''       ,      snake_case_       ):
      pass






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

   __snake_case							       =   '''__test_patch_submodule_successive_join__'''
   __snake_case							       =   '''__test_patch_submodule_successive_dirname__'''
   __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 lowerCamelCase__    (							)      ->				Tuple:
   __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

