






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 		_a					(   a				:Tuple			,							a				:Optional[Union[str, bool]] = None				)							->    Optional[int]:
 a							=   importlib.import_module(a				)

 # TODO(QL): always update the module to add subsequent new authentication
 if hasattr(a			,							'''_patched_for_streaming'''				) and module._patched_for_streaming:
  return

 def wrap_auth(a				:Optional[Any]				):
  @wraps(a				)
  def wrapper(*a				:List[Any]			,							**a				:Optional[int]				):
   return function(*a			,							use_auth_token=a			,							**a				)

  a							=   '''wrap_auth'''
  return wrapper

 # open files in a streaming fashion
 patch_submodule(a			,							'''open'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''os.listdir'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''os.walk'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''glob.glob'''			,							wrap_auth(a				)				).start()
 # allow to navigate in remote zip files
 patch_submodule(a			,							'''os.path.join'''			,							a				).start()
 patch_submodule(a			,							'''os.path.dirname'''			,							a				).start()
 patch_submodule(a			,							'''os.path.basename'''			,							a				).start()
 patch_submodule(a			,							'''os.path.relpath'''			,							a				).start()
 patch_submodule(a			,							'''os.path.split'''			,							a				).start()
 patch_submodule(a			,							'''os.path.splitext'''			,							a				).start()
 # allow checks on paths
 patch_submodule(a			,							'''os.path.exists'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''os.path.isdir'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''os.path.isfile'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''os.path.getsize'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''pathlib.Path'''			,							a				).start()
 # file readers
 patch_submodule(a			,							'''gzip.open'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''numpy.load'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''pandas.read_csv'''			,							wrap_auth(a				)			,							attrs=['''__version__''']				).start()
 patch_submodule(a			,							'''pandas.read_excel'''			,							wrap_auth(a				)			,							attrs=['''__version__''']				).start()
 patch_submodule(a			,							'''scipy.io.loadmat'''			,							wrap_auth(a				)			,							attrs=['''__version__''']				).start()
 patch_submodule(a			,							'''xml.etree.ElementTree.parse'''			,							wrap_auth(a				)				).start()
 patch_submodule(a			,							'''xml.dom.minidom.parse'''			,							wrap_auth(a				)				).start()
 a							=   True

def 		_a					(   a				:"DatasetBuilder"				)							->    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":
    a							=   imports[1]
    a							=   '''.'''.join(builder.__module__.split('''.'''				)[:-1] + [internal_import_name]				)
    extend_module_for_streaming(a			,							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

 a							=   [
     cls.__module__
     for cls in type(a				).__mro__[1:]  # make sure it's not the same module we've already patched
     if issubclass(cls			,							a				) 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(a			,							use_auth_token=builder.use_auth_token				)










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__            =	{"configuration_visual_bert": ["VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "VisualBertConfig"]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase__            =	[
         "VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
         "VisualBertForMultipleChoice",
         "VisualBertForPreTraining",
         "VisualBertForQuestionAnswering",
         "VisualBertForRegionToPhraseAlignment",
         "VisualBertForVisualReasoning",
         "VisualBertLayer",
         "VisualBertModel",
         "VisualBertPreTrainedModel",
     ]


if TYPE_CHECKING:
     from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_visual_bert import (
              VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              VisualBertForMultipleChoice,
              VisualBertForPreTraining,
              VisualBertForQuestionAnswering,
              VisualBertForRegionToPhraseAlignment,
              VisualBertForVisualReasoning,
              VisualBertLayer,
              VisualBertModel,
              VisualBertPreTrainedModel,
          )


else:
     import sys

     UpperCAmelCase__            =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


