


import importlib.metadata
import sys

from transformers.testing_utils import TestCasePlus
from transformers.utils.versions import require_version, require_version_core


lowerCAmelCase__   	=				importlib.metadata.version('numpy')
lowerCAmelCase__   	=				'.'.join([str(x) for x in sys.version_info[:3]])







class   lowerCAmelCase__ (       a):




     '''simple docstring'''


     def 				_lowerCamelCase				(		self)    ->       int:
            # lt + different version strings
            require_version_core("numpy<1000.4.5")
            require_version_core("numpy<1000.4")
            require_version_core("numpy<1000")

            # le
            require_version_core("numpy<=1000.4.5")
            require_version_core(F"numpy<={numpy_ver}")

            # eq
            require_version_core(F"numpy=={numpy_ver}")

            # ne
            require_version_core("numpy!=1000.4.5")

            # ge
            require_version_core("numpy>=1.0")
            require_version_core("numpy>=1.0.0")
            require_version_core(F"numpy>={numpy_ver}")

            # gt
            require_version_core("numpy>1.0.0")

            # mix
            require_version_core("numpy>1.0.0,<1000")

            # requirement w/o version
            require_version_core("numpy")

            # unmet requirements due to version conflict
            for req in ["numpy==1.0.0", "numpy>=1000.0.0", F"numpy<{numpy_ver}"]:
                   try:
                          require_version_core(__lowerCamelCase)
                   except ImportError as e:
                          self.assertIn(F"{req} is required"				,		str(__lowerCamelCase))
                          self.assertIn("but found"				,		str(__lowerCamelCase))

        # unmet requirements due to missing module
            for req in ["numpipypie>1", "numpipypie2"]:
                   try:
                          require_version_core(__lowerCamelCase)
                   except importlib.metadata.PackageNotFoundError as e:
                          self.assertIn(F"The '{req}' distribution was not found and is required by this application"				,		str(__lowerCamelCase))
                          self.assertIn("Try: pip install transformers -U"				,		str(__lowerCamelCase))

        # bogus requirements formats:
        # 1. whole thing
            for req in ["numpy??1.0.0", "numpy1.0.0"]:
                   try:
                          require_version_core(__lowerCamelCase)
                   except ValueError as e:
                          self.assertIn("requirement needs to be in the pip package format"				,		str(__lowerCamelCase))
        # 2. only operators
            for req in ["numpy=1.0.0", "numpy == 1.00", "numpy<>1.0.0", "numpy><1.00", "numpy>>1.0.0"]:
                   try:
                          require_version_core(__lowerCamelCase)
                   except ValueError as e:
                          self.assertIn("need one of "				,		str(__lowerCamelCase))


     def 				_lowerCamelCase				(		self)    ->       Optional[Any]:
            # matching requirement
            require_version("python>=3.6.0")

            # not matching requirements
            for req in ["python>9.9.9", "python<3.0.0"]:
                   try:
                          require_version_core(__lowerCamelCase)
                   except ImportError as e:
                          self.assertIn(F"{req} is required"				,		str(__lowerCamelCase))
                          self.assertIn(F"but found python=={python_ver}"				,		str(__lowerCamelCase))




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__   	=				get_logger(__name__)


if TYPE_CHECKING:
    from .builder import DatasetBuilder
def 							_UpperCAmelCase       (UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Optional[Union[str, bool]] = None		):
       _A   : 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(UpperCamelCase__  :						Optional[int]		):
              @wraps(UpperCamelCase__		)
              def wrapper(*UpperCamelCase__  :						str       ,							**UpperCamelCase__  :						Optional[int]		):
                     return function(*UpperCamelCase__       ,							use_auth_token=UpperCamelCase__       ,							**UpperCamelCase__		)

              _A   : 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()
       _A   : Any       					=				True






def 							_UpperCAmelCase       (UpperCamelCase__  :						"DatasetBuilder"		):
       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   : Optional[Any]       					=				imports[1]
                            _A   : 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

       _A   : 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		)
