
"""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        _lowerCamelCase(__UpperCamelCase       ,					__UpperCamelCase = None			)							->					Optional[Any]:
	_lowerCAmelCase								=importlib.import_module(__UpperCamelCase			)

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

	def wrap_auth(__UpperCamelCase			):
		@wraps(__UpperCamelCase			)
		def wrapper(*__UpperCamelCase       ,					**__UpperCamelCase			):
			return function(*__UpperCamelCase       ,					use_auth_token=__UpperCamelCase       ,					**__UpperCamelCase			)

		_lowerCAmelCase								="""wrap_auth"""
		return wrapper

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



def        _lowerCamelCase(__UpperCamelCase			)							->					int:
	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":
				_lowerCAmelCase								=imports[1]
				_lowerCAmelCase								=""".""".join(builder.__module__.split("""."""			)[:-1] + [internal_import_name]			)
				extend_module_for_streaming(__UpperCamelCase       ,					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

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





"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__A					=			{
    'configuration_donut_swin': ['DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DonutSwinConfig'],
    'processing_donut': ['DonutProcessor'],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A					=			[
			    'DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'DonutSwinModel',
			    'DonutSwinPreTrainedModel',
			]

try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A					=			['DonutFeatureExtractor']
			__A					=			['DonutImageProcessor']


if TYPE_CHECKING:
			from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
			from .processing_donut import DonutProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_donut_swin import (
						    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
						    DonutSwinModel,
						    DonutSwinPreTrainedModel,
						)

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .feature_extraction_donut import DonutFeatureExtractor
						from .image_processing_donut import DonutImageProcessor

else:
			import sys

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



