


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


lowerCAmelCase__						:Any         =							get_logger(__name__)


if TYPE_CHECKING:
		from .builder import DatasetBuilder

def  lowerCAmelCase__				(    a__:	Union[str, Any]    ,						a__:	List[str] = None )						->	int:


							'''simple docstring'''





							_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__:	str    ,						**a__:	int ):
																					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__:	Any )						->	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					=    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 )




from __future__ import annotations

def  lowerCAmelCase__				(    a__:	list[int]    ,						a__:	int )						->	list[int]:


							'''simple docstring'''





							_UpperCAmelCase					=    {}
							for index, val in enumerate(a__ ):
														_UpperCAmelCase					=    target - val
														if compl in chk_map:
																					return [chk_map[compl], index]
														_UpperCAmelCase					=    index
							return []


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		print(f'''{two_sum([2, 7, 1_1, 1_5], 9) = }''')
