code: 
  
  
  
  import importlib
  import inspect
  from functools import wraps
  from typing import TYPE_CHECKING, Optional, Union
  
  from .download.streaming_download_manager import (
      xbasename,
      xdirname,
      xet_parse,
      xexists,
      xgetsize,
      xglob,
      xgzip_open,
      xisdir,
      xisfile,
      xjoin,
      xlistdir,
      xnumpy_load,
      xopen,
      xpandas_read_csv,
      xpandas_read_excel,
      xPath,
      xrelpath,
      xsio_loadmat,
      xsplit,
      xsplitext,
      xwalk,
      xxml_dom_minidom_parse,
  )
  from .utils.logging import get_logger
  from .utils.patching import patch_submodule
  from .utils.py_utils import get_imports
  
  
  __UpperCAmelCase      = get_logger(__name__)
  
  
  if TYPE_CHECKING:
      from .builder import DatasetBuilder
  def 	UpperCamelCase			(     snake_case__ :					Any ,  snake_case__ :					Optional[Union[str, bool]] = None			)			->  Any:
     UpperCamelCase					:						Optional[int]					=			importlib.import_module(snake_case__			)
  
     # TODO(QL): always update the module to add subsequent new authentication
     if hasattr(snake_case__ ,  '_patched_for_streaming'			) and module._patched_for_streaming:
        return
  
     def wrap_auth(snake_case__ :					List[Any]			):
        @wraps(snake_case__			)
        def wrapper(*snake_case__ :					Dict ,  **snake_case__ :					Union[str, Any]			):
           return function(*snake_case__ ,  use_auth_token=snake_case__ ,  **snake_case__			)
  
        UpperCamelCase					:						int					=			'wrap_auth'
        return wrapper
  
     # open files in a streaming fashion
     patch_submodule(snake_case__ ,  'open' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'os.listdir' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'os.walk' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'glob.glob' ,  wrap_auth(snake_case__			)			).start()
     # allow to navigate in remote zip files
     patch_submodule(snake_case__ ,  'os.path.join' ,  snake_case__			).start()
     patch_submodule(snake_case__ ,  'os.path.dirname' ,  snake_case__			).start()
     patch_submodule(snake_case__ ,  'os.path.basename' ,  snake_case__			).start()
     patch_submodule(snake_case__ ,  'os.path.relpath' ,  snake_case__			).start()
     patch_submodule(snake_case__ ,  'os.path.split' ,  snake_case__			).start()
     patch_submodule(snake_case__ ,  'os.path.splitext' ,  snake_case__			).start()
     # allow checks on paths
     patch_submodule(snake_case__ ,  'os.path.exists' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'os.path.isdir' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'os.path.isfile' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'os.path.getsize' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'pathlib.Path' ,  snake_case__			).start()
     # file readers
     patch_submodule(snake_case__ ,  'gzip.open' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'numpy.load' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'pandas.read_csv' ,  wrap_auth(snake_case__			) ,  attrs=['__version__']			).start()
     patch_submodule(snake_case__ ,  'pandas.read_excel' ,  wrap_auth(snake_case__			) ,  attrs=['__version__']			).start()
     patch_submodule(snake_case__ ,  'scipy.io.loadmat' ,  wrap_auth(snake_case__			) ,  attrs=['__version__']			).start()
     patch_submodule(snake_case__ ,  'xml.etree.ElementTree.parse' ,  wrap_auth(snake_case__			)			).start()
     patch_submodule(snake_case__ ,  'xml.dom.minidom.parse' ,  wrap_auth(snake_case__			)			).start()
     UpperCamelCase					:						List[Any]					=			True
  
  
  def 	UpperCamelCase			(     snake_case__ :					"DatasetBuilder"			)			->  List[Any]:
     extend_module_for_streaming(builder.__module__ ,  use_auth_token=builder.use_auth_token			)
     # if needed, we also have to extend additional internal imports (like wmt14 -> wmt_utils)
     if not builder.__module__.startswith('datasets.'			):  # check that it's not a packaged builder like csv
        for imports in get_imports(inspect.getfile(builder.__class__			)			):
           if imports[0] == "internal":
              UpperCamelCase					:						Optional[int]					=			imports[1]
              UpperCamelCase					:						Union[str, Any]					=			'.'.join(builder.__module__.split('.'			)[:-1] + [internal_import_name]			)
              extend_module_for_streaming(snake_case__ ,  use_auth_token=builder.use_auth_token			)
  
      # builders can inherit from other builders that might use streaming functionality
      # (for example, ImageFolder and AudioFolder inherit from FolderBuilder which implements examples generation)
      # but these parents builders are not patched automatically as they are not instantiated, so we patch them here
     from .builder import DatasetBuilder
  
     UpperCamelCase					:						Dict					=			[
         cls.__module__
         for cls in type(snake_case__			).__mro__[1:]  # make sure it's not the same module we've already patched
         if issubclass(cls ,  snake_case__			) and cls.__module__ != DatasetBuilder.__module__
     ]  # check it's not a standard builder from datasets.builder
     for module in parent_builder_modules:
        extend_module_for_streaming(snake_case__ ,  use_auth_token=builder.use_auth_token			)
  
  
  
  
style_context: 
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
  
  
  __UpperCAmelCase      = {
      '''configuration_deta''': ['''DETA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DetaConfig'''],
  }
  
  try:
      if not is_vision_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      __UpperCAmelCase      = ['''DetaImageProcessor''']
  
  try:
      if not is_torch_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      __UpperCAmelCase      = [
          '''DETA_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''DetaForObjectDetection''',
          '''DetaModel''',
          '''DetaPreTrainedModel''',
      ]
  
  
  if TYPE_CHECKING:
      from .configuration_deta import DETA_PRETRAINED_CONFIG_ARCHIVE_MAP, DetaConfig
  
      try:
          if not is_vision_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .image_processing_deta import DetaImageProcessor
  
      try:
          if not is_torch_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_deta import (
              DETA_PRETRAINED_MODEL_ARCHIVE_LIST,
              DetaForObjectDetection,
              DetaModel,
              DetaPreTrainedModel,
          )
  
  else:
      import sys
  
      __UpperCAmelCase      = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  