
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A        =					{'''configuration_visual_bert''': ['''VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''VisualBertConfig''']}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _A        =					[
          '''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

      _A        =					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





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


_A	  =					get_logger(__name__)


if TYPE_CHECKING:
      from .builder import DatasetBuilder




def 				lowerCamelCase__				(						a__  :  int	,      a__  :  Optional[Union[str, bool]] = None     )		->	Dict:
       UpperCamelCase_							       =       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__  :  int     ):
              @wraps(a__     )
              def wrapper(*a__  :  int	,      **a__  :  List[str]     ):
                     return function(*a__	,      use_auth_token=a__	,      **a__     )

              UpperCamelCase_							       =       """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()
       UpperCamelCase_							       =       True







def 				lowerCamelCase__				(						a__  :  "DatasetBuilder"     )		->	Tuple:
       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_							       =       imports[1]
                            UpperCamelCase_							       =       """.""".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

       UpperCamelCase_							       =       [
           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     )



