


'''simple docstring'''

from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching

def _SCREAMING_SNAKE_CASE ()			->			Optional[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

       lowercase__      =					'''__test_patch_submodule_mock__'''
       with patch_submodule(_test_patching    ,					'''os.path.join'''    ,					A			):
              # 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 ()			->			Union[str, Any]:






       """simple docstring"""







       assert _test_patching.open is open

       lowercase__      =					'''__test_patch_submodule_builtin_mock__'''
       # _test_patching has "open" in its globals
       assert _test_patching.open is open
       with patch_submodule(_test_patching    ,					'''open'''    ,					A			):
              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 ()			->			Optional[Any]:






       """simple docstring"""







       lowercase__      =					'''__test_patch_submodule_missing_mock__'''
       with patch_submodule(_test_patching    ,					'''pandas.read_csv'''    ,					A			):
              pass

def _SCREAMING_SNAKE_CASE ()			->			List[Any]:






       """simple docstring"""







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

def _SCREAMING_SNAKE_CASE ()			->			str:






       """simple docstring"""







       lowercase__      =					'''__test_patch_submodule_start_and_stop_mock__'''
       lowercase__      =					patch_submodule(_test_patching    ,					'''open'''    ,					A			)
       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 ()			->			Tuple:






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

       lowercase__      =					'''__test_patch_submodule_successive_join__'''
       lowercase__      =					'''__test_patch_submodule_successive_dirname__'''
       lowercase__      =					'''__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'''    ,					A			):
              with patch_submodule(_test_patching    ,					'''os.rename'''    ,					A			):
                     with patch_submodule(_test_patching    ,					'''os.path.dirname'''    ,					A			):
                            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'''    ,					A			):
              with patch_submodule(_test_patching    ,					'''os.path.join'''    ,					A			):
                     with patch_submodule(_test_patching    ,					'''os.path.dirname'''    ,					A			):
                            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 ()			->			Optional[int]:






       """simple docstring"""







       lowercase__      =					'''__test_patch_submodule_doesnt_exist_mock__'''
       with patch_submodule(_test_patching    ,					'''__module_that_doesn_exist__.__attribute_that_doesn_exist__'''    ,					A			):
              pass
       with patch_submodule(_test_patching    ,					'''os.__attribute_that_doesn_exist__'''    ,					A			):
              pass








'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase				:  Tuple    		=      {
    'configuration_distilbert': [
        'DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'DistilBertConfig',
        'DistilBertOnnxConfig',
    ],
    'tokenization_distilbert': ['DistilBertTokenizer'],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:  str    		=      ['DistilBertTokenizerFast']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:  List[str]    		=      [
     'DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
     'DistilBertForMaskedLM',
     'DistilBertForMultipleChoice',
     'DistilBertForQuestionAnswering',
     'DistilBertForSequenceClassification',
     'DistilBertForTokenClassification',
     'DistilBertModel',
     'DistilBertPreTrainedModel',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:  Union[str, Any]    		=      [
     'TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFDistilBertForMaskedLM',
     'TFDistilBertForMultipleChoice',
     'TFDistilBertForQuestionAnswering',
     'TFDistilBertForSequenceClassification',
     'TFDistilBertForTokenClassification',
     'TFDistilBertMainLayer',
     'TFDistilBertModel',
     'TFDistilBertPreTrainedModel',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:  str    		=      [
     'FlaxDistilBertForMaskedLM',
     'FlaxDistilBertForMultipleChoice',
     'FlaxDistilBertForQuestionAnswering',
     'FlaxDistilBertForSequenceClassification',
     'FlaxDistilBertForTokenClassification',
     'FlaxDistilBertModel',
     'FlaxDistilBertPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_distilbert import (
     DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
     DistilBertConfig,
     DistilBertOnnxConfig,
 )
 from .tokenization_distilbert import DistilBertTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_distilbert_fast import DistilBertTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_distilbert import (
      DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      DistilBertForMaskedLM,
      DistilBertForMultipleChoice,
      DistilBertForQuestionAnswering,
      DistilBertForSequenceClassification,
      DistilBertForTokenClassification,
      DistilBertModel,
      DistilBertPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_distilbert import (
      TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFDistilBertForMaskedLM,
      TFDistilBertForMultipleChoice,
      TFDistilBertForQuestionAnswering,
      TFDistilBertForSequenceClassification,
      TFDistilBertForTokenClassification,
      TFDistilBertMainLayer,
      TFDistilBertModel,
      TFDistilBertPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_distilbert import (
      FlaxDistilBertForMaskedLM,
      FlaxDistilBertForMultipleChoice,
      FlaxDistilBertForQuestionAnswering,
      FlaxDistilBertForSequenceClassification,
      FlaxDistilBertForTokenClassification,
      FlaxDistilBertModel,
      FlaxDistilBertPreTrainedModel,
  )

else:
 import sys

 lowerCamelCase				:  int    		=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




