

"""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 						_A						(						UpperCamelCase_  : Tuple,    UpperCamelCase_  : Optional[Union[str, bool]] = None)			->		Union[str, Any]:
   '''simple docstring'''


   __lowercase			=		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_  : Dict):
      @wraps(UpperCamelCase_)
      def wrapper(*UpperCamelCase_  : Union[str, Any],    **UpperCamelCase_  : List[str]):
         return function(*UpperCamelCase_,    use_auth_token=UpperCamelCase_,    **UpperCamelCase_)

      __lowercase			=		"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()
   __lowercase			=		True




def 						_A						(						UpperCamelCase_  : "DatasetBuilder")			->		List[str]:
   '''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":
            __lowercase			=		imports[1]
            __lowercase			=		".".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

   __lowercase			=		[
       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"""





def 						_A						(						UpperCamelCase_  : float,    UpperCamelCase_  : float)			->		float:
   '''simple docstring'''


   __lowercase			=		float()
   try:
      __lowercase			=		mass * acceleration
   except Exception:
      return -0.0
   return force


if __name__ == "__main__":
   import doctest

   # run doctest
   doctest.testmod()

   # demo
   _a				   =							12.5
   _a				   =							10
   _a				   =							newtons_second_law_of_motion(mass, acceleration)
   print('The force is ', force, 'N')




