
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


__SCREAMING_SNAKE_CASE			:   Union[str, Any]         =     get_logger(__name__)


if TYPE_CHECKING:
  from .builder import DatasetBuilder
def     UpperCAmelCase__							(       __magic_name__						:     Optional[Any]							,  __magic_name__						:     Optional[Union[str, bool]] = None  ):


     '''simple docstring'''

     lowerCAmelCase		:					Dict  	=     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(__magic_name__						:     Optional[int]  ):
          @wraps(UpperCamelCase__  )
          def wrapper(*__magic_name__						:     str							,  **__magic_name__						:     Optional[int]  ):
               return function(*UpperCamelCase__							,  use_auth_token=UpperCamelCase__							,  **UpperCamelCase__  )

          lowerCAmelCase		:					List[Any]  	=     "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		:					Any  	=     True
def     UpperCAmelCase__							(       __magic_name__						:     "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":
                    lowerCAmelCase		:					Optional[Any]  	=     imports[1]
                    lowerCAmelCase		:					int  	=     ".".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		:					Tuple  	=     [
         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  )


from ctypes import c_float, sizeof
from enum import Enum
from typing import TYPE_CHECKING, Optional, Union


if TYPE_CHECKING:
		from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore


class 		__magic_name__   (						snake_case    ):
		_lowerCAmelCase		=	c_float





		@property
		def       _A							(							self    :	int				):
							return sizeof(self.value				)



def     UpperCAmelCase__							(       __magic_name__						:     int							,  __magic_name__						:     int							,  __magic_name__						:     int = 0  ):


					'''simple docstring'''

					if dimension <= 0:
										lowerCAmelCase		:					Tuple  	=     fixed_dimension

					dimension -= num_token_to_add
					return dimension
def     UpperCAmelCase__							(       __magic_name__						:     int							,  __magic_name__						:     ParameterFormat  ):


					'''simple docstring'''

					return num_parameters * dtype.size
def     UpperCAmelCase__							(       __magic_name__						:     str  ):


					'''simple docstring'''

					from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

					try:
										return AutoProcessor.from_pretrained(__magic_name__  )
					except (ValueError, OSError, KeyError):
										lowerCAmelCase	,							lowerCAmelCase		:					Any  	=     None, None
										try:
															lowerCAmelCase		:					Union[str, Any]  	=     AutoTokenizer.from_pretrained(__magic_name__  )
										except (OSError, KeyError):
															pass
										try:
															lowerCAmelCase		:					List[Any]  	=     AutoFeatureExtractor.from_pretrained(__magic_name__  )
										except (OSError, KeyError):
															pass

										if tokenizer is not None and feature_extractor is not None:
															raise ValueError(
															    f'''Couldn\'t auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor.'''  )
										elif tokenizer is None and feature_extractor is None:
															return None
										elif tokenizer is not None:
															return tokenizer
										else:
															return feature_extractor
