




from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching







def SCREAMING_SNAKE_CASE       ( )     -> int:



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

       A__   				=					'''__test_patch_submodule_mock__'''
       with patch_submodule(_test_patching				,       '''os.path.join'''				,       lowercase_		):
              # 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 SCREAMING_SNAKE_CASE       ( )     -> Optional[int]:



       """simple docstring"""

       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'''				,       lowercase_		):
              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 SCREAMING_SNAKE_CASE       ( )     -> List[Any]:



       """simple docstring"""

       A__   				=					'''__test_patch_submodule_missing_mock__'''
       with patch_submodule(_test_patching				,       '''pandas.read_csv'''				,       lowercase_		):
              pass







def SCREAMING_SNAKE_CASE       ( )     -> List[Any]:



       """simple docstring"""

       A__   				=					'''__test_patch_submodule_missing_builtin_mock__'''
       # _test_patching doesn't have "len" in its globals
       assert getattr(_test_patching				,       '''len'''				,       lowercase_		) is None
       with patch_submodule(_test_patching				,       '''len'''				,       lowercase_		):
              assert _test_patching.len is mock
       assert _test_patching.len is len







def SCREAMING_SNAKE_CASE       ( )     -> Optional[Any]:



       """simple docstring"""

       A__   				=					'''__test_patch_submodule_start_and_stop_mock__'''
       A__   				=					patch_submodule(_test_patching				,       '''open'''				,       lowercase_		)
       assert _test_patching.open is open
       patch.start()
       assert _test_patching.open is mock
       patch.stop()
       assert _test_patching.open is open







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

       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'''				,       lowercase_		):
              with patch_submodule(_test_patching				,       '''os.rename'''				,       lowercase_		):
                     with patch_submodule(_test_patching				,       '''os.path.dirname'''				,       lowercase_		):
                            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'''				,       lowercase_		):
              with patch_submodule(_test_patching				,       '''os.path.join'''				,       lowercase_		):
                     with patch_submodule(_test_patching				,       '''os.path.dirname'''				,       lowercase_		):
                            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 SCREAMING_SNAKE_CASE       ( )     -> str:



       """simple docstring"""

       A__   				=					'''__test_patch_submodule_doesnt_exist_mock__'''
       with patch_submodule(_test_patching				,       '''__module_that_doesn_exist__.__attribute_that_doesn_exist__'''				,       lowercase_		):
              pass
       with patch_submodule(_test_patching				,       '''os.__attribute_that_doesn_exist__'''				,       lowercase_		):
              pass








from typing import TYPE_CHECKING

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


_lowerCamelCase			:	Union[str, Any]							 =     {"""configuration_dpt""": ["""DPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DPTConfig"""]}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase			:	Optional[Any]							 =     ["""DPTFeatureExtractor"""]
  _lowerCamelCase			:	int							 =     ["""DPTImageProcessor"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase			:	Optional[int]							 =     [
      """DPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """DPTForDepthEstimation""",
      """DPTForSemanticSegmentation""",
      """DPTModel""",
      """DPTPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_dpt import DPT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPTConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_dpt import DPTFeatureExtractor
    from .image_processing_dpt import DPTImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_dpt import (
        DPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        DPTForDepthEstimation,
        DPTForSemanticSegmentation,
        DPTModel,
        DPTPreTrainedModel,
    )


else:
  import sys

  _lowerCamelCase			:	Any							 =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


