






'''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


SCREAMING_SNAKE_CASE_				      =							get_logger(__name__)


if TYPE_CHECKING:
  from .builder import DatasetBuilder






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__ = None		):
 __a    :	List[str]									=						importlib.import_module(SCREAMING_SNAKE_CASE__		)

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

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

  __a    :	str									=						'wrap_auth'
  return wrapper

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






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 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":
    __a    :	List[Any]									=						imports[1]
    __a    :	Dict									=						'.'.join(builder.__module__.split('.'		)[:-1] + [internal_import_name]		)
    extend_module_for_streaming(SCREAMING_SNAKE_CASE__       ,		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

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












'''simple docstring'''


from typing import List, Optional, Tuple, Union

from . import logging
from .import_utils import is_torch_available, is_torch_version


if is_torch_available():
  import torch

SCREAMING_SNAKE_CASE_				      =							logging.get_logger(__name__)  # pylint: disable=invalid-name

try:
  from torch._dynamo import allow_in_graph as maybe_allow_in_graph
except (ImportError, ModuleNotFoundError):






  def   lowerCAmelCase__			(					cls		):
   return cls






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__ = None       ,		SCREAMING_SNAKE_CASE__ = None       ,		SCREAMING_SNAKE_CASE__ = None       ,		SCREAMING_SNAKE_CASE__ = None       ,		):
 __a    :	int									=						device
 __a    :	Union[str, Any]									=						shape[0]

 __a    :	Union[str, Any]									=						layout or torch.strided
 __a    :	Any									=						device or torch.device('cpu'		)

 if generator is not None:
  __a    :	Optional[int]									=						generator.device.type if not isinstance(SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__		) else generator[0].device.type
  if gen_device_type != device.type and gen_device_type == "cpu":
   __a    :	int									=						'cpu'
   if device != "mps":
    logger.info(
        f'''The passed generator was created on \'cpu\' even though a tensor on {device} was expected.'''
        f''' Tensors will be created on \'cpu\' and then moved to {device}. Note that one can probably'''
        f''' slighly speed up this function by passing a generator that was created on the {device} device.'''		)
  elif gen_device_type != device.type and gen_device_type == "cuda":
   raise ValueError(f'''Cannot generate a {device} tensor from a generator of type {gen_device_type}.'''		)

 if isinstance(SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__		):
  __a    :	Optional[int]									=						(1,) + shape[1:]
  __a    :	Dict									=						[
      torch.randn(SCREAMING_SNAKE_CASE__       ,		generator=generator[i]       ,		device=SCREAMING_SNAKE_CASE__       ,		dtype=SCREAMING_SNAKE_CASE__       ,		layout=SCREAMING_SNAKE_CASE__		)
      for i in range(SCREAMING_SNAKE_CASE__		)
  ]
  __a    :	List[str]									=						torch.cat(SCREAMING_SNAKE_CASE__       ,		dim=0		).to(SCREAMING_SNAKE_CASE__		)
 else:
  __a    :	Tuple									=						torch.randn(SCREAMING_SNAKE_CASE__       ,		generator=SCREAMING_SNAKE_CASE__       ,		device=SCREAMING_SNAKE_CASE__       ,		dtype=SCREAMING_SNAKE_CASE__       ,		layout=SCREAMING_SNAKE_CASE__		).to(SCREAMING_SNAKE_CASE__		)

 return latents






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 if is_torch_version('<'       ,		'2.0.0'		) or not hasattr(SCREAMING_SNAKE_CASE__       ,		'_dynamo'		):
  return False
 return isinstance(SCREAMING_SNAKE_CASE__       ,		torch._dynamo.eval_frame.OptimizedModule		)




