





from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






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

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






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

   a__	:						Union[str, Any]      		=  "__test_patch_submodule_successive_join__"
   a__	:						Optional[Any]      		=  "__test_patch_submodule_successive_dirname__"
   a__	:						List[Any]      		=  "__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  (      ):
   a__	:						Tuple      		=  "__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








from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


SCREAMING_SNAKE_CASE__       :			List[str]			      =						{"""configuration_van""": ["""VAN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """VanConfig"""]}


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			Optional[int]			      =						[
      """VAN_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """VanForImageClassification""",
      """VanModel""",
      """VanPreTrainedModel""",
  ]

if TYPE_CHECKING:
  from .configuration_van import VAN_PRETRAINED_CONFIG_ARCHIVE_MAP, VanConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_van import (
        VAN_PRETRAINED_MODEL_ARCHIVE_LIST,
        VanForImageClassification,
        VanModel,
        VanPreTrainedModel,
    )

else:
  import sys

  SCREAMING_SNAKE_CASE__       :			List[str]			      =						_LazyModule(__name__, globals()["""__file__"""], _import_structure)

