


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 	_lowerCamelCase  (		A_  :	List[str]							,  A_  :	Optional[Union[str, bool]] = None      )			->			int:

   '''simple docstring'''






   UpperCamelCase__ :			List[str] 						=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_  :	Tuple      ):
      @wraps(A_      )
      def wrapper(*A_  :	int							,  **A_  :	Optional[int]      ):
         return function(*A_							,  use_auth_token=A_							,  **A_      )

      UpperCamelCase__ :			List[Any] 						="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__ :			Tuple 						=True
def 	_lowerCamelCase  (		A_  :	"DatasetBuilder"      )			->			Optional[Any]:

   '''simple docstring'''






   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__ :			Tuple 						=imports[1]
            UpperCamelCase__ :			List[Any] 						=".".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__ :			Optional[int] 						=[
       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_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCAmelCase      			=  {
    """configuration_switch_transformers""": [
        """SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """SwitchTransformersConfig""",
        """SwitchTransformersOnnxConfig""",
    ]
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __UpperCAmelCase      			=  [
         """SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """SwitchTransformersEncoderModel""",
         """SwitchTransformersForConditionalGeneration""",
         """SwitchTransformersModel""",
         """SwitchTransformersPreTrainedModel""",
         """SwitchTransformersTop1Router""",
         """SwitchTransformersSparseMLP""",
     ]


if TYPE_CHECKING:
     from .configuration_switch_transformers import (
         SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP,
         SwitchTransformersConfig,
         SwitchTransformersOnnxConfig,
     )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_switch_transformers import (
              SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST,
              SwitchTransformersEncoderModel,
              SwitchTransformersForConditionalGeneration,
              SwitchTransformersModel,
              SwitchTransformersPreTrainedModel,
              SwitchTransformersSparseMLP,
              SwitchTransformersTopaRouter,
          )


else:
     import sys

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

