'''simple docstring'''
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 			_UpperCamelCase			(  _a						:						Dict					,  _a						:						Optional[Union[str, bool]] = None      ):




    """simple docstring"""



    __UpperCamelCase						:						Any		     =	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						:						str      ):
        @wraps(_a      )
        def wrapper(*_a						:						Dict					,  **_a						:						Dict      ):
            return function(*_a					,  use_auth_token=_a					,  **_a      )

        __UpperCamelCase						:						Tuple		     =	'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						:						List[str]		     =	True







def 			_UpperCamelCase			(  _a						:						"DatasetBuilder"      ):




    """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						:						Any		     =	imports[1]
                __UpperCamelCase						:						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      )




'''simple docstring'''
from .prime_check import Test

Test()



