Upload edit\Qwen3-TTS-test\.venv\Lib\site-packages\joblib\func_inspect.py with huggingface_hub

edit//Qwen3-TTS-test//.venv//Lib//site-packages//joblib//func_inspect.py

@@ -0,0 +1,379 @@
+"""
+My own variation on function-specific inspect-like features.
+"""
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Copyright (c) 2009 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+
+import collections
+import inspect
+import os
+import re
+import warnings
+from itertools import islice
+from tokenize import open as open_py_source
+
+from .logger import pformat
+
+full_argspec_fields = (
+    "args varargs varkw defaults kwonlyargs kwonlydefaults annotations"
+)
+full_argspec_type = collections.namedtuple("FullArgSpec", full_argspec_fields)
+
+
+def get_func_code(func):
+    """Attempts to retrieve a reliable function code hash.
+
+    The reason we don't use inspect.getsource is that it caches the
+    source, whereas we want this to be modified on the fly when the
+    function is modified.
+
+    Returns
+    -------
+    func_code: string
+        The function code
+    source_file: string
+        The path to the file in which the function is defined.
+    first_line: int
+        The first line of the code in the source file.
+
+    Notes
+    ------
+    This function does a bit more magic than inspect, and is thus
+    more robust.
+    """
+    source_file = None
+    try:
+        code = func.__code__
+        source_file = code.co_filename
+        if not os.path.exists(source_file):
+            # Use inspect for lambda functions and functions defined in an
+            # interactive shell, or in doctests
+            source_code = "".join(inspect.getsourcelines(func)[0])
+            line_no = 1
+            if source_file.startswith("<doctest "):
+                source_file, line_no = re.match(
+                    r"\<doctest (.*\.rst)\[(.*)\]\>", source_file
+                ).groups()
+                line_no = int(line_no)
+                source_file = "<doctest %s>" % source_file
+            return source_code, source_file, line_no
+        # Try to retrieve the source code.
+        with open_py_source(source_file) as source_file_obj:
+            first_line = code.co_firstlineno
+            # All the lines after the function definition:
+            source_lines = list(islice(source_file_obj, first_line - 1, None))
+        return "".join(inspect.getblock(source_lines)), source_file, first_line
+    except:  # noqa: E722
+        # If the source code fails, we use the hash. This is fragile and
+        # might change from one session to another.
+        if hasattr(func, "__code__"):
+            # Python 3.X
+            return str(func.__code__.__hash__()), source_file, -1
+        else:
+            # Weird objects like numpy ufunc don't have __code__
+            # This is fragile, as quite often the id of the object is
+            # in the repr, so it might not persist across sessions,
+            # however it will work for ufuncs.
+            return repr(func), source_file, -1
+
+
+def _clean_win_chars(string):
+    """Windows cannot encode some characters in filename."""
+    import urllib
+
+    if hasattr(urllib, "quote"):
+        quote = urllib.quote
+    else:
+        # In Python 3, quote is elsewhere
+        import urllib.parse
+
+        quote = urllib.parse.quote
+    for char in ("<", ">", "!", ":", "\\"):
+        string = string.replace(char, quote(char))
+    return string
+
+
+def get_func_name(func, resolv_alias=True, win_characters=True):
+    """Return the function import path (as a list of module names), and
+    a name for the function.
+
+    Parameters
+    ----------
+    func: callable
+        The func to inspect
+    resolv_alias: boolean, optional
+        If true, possible local aliases are indicated.
+    win_characters: boolean, optional
+        If true, substitute special characters using urllib.quote
+        This is useful in Windows, as it cannot encode some filenames
+    """
+    if hasattr(func, "__module__"):
+        module = func.__module__
+    else:
+        try:
+            module = inspect.getmodule(func)
+        except TypeError:
+            if hasattr(func, "__class__"):
+                module = func.__class__.__module__
+            else:
+                module = "unknown"
+    if module is None:
+        # Happens in doctests, eg
+        module = ""
+    if module == "__main__":
+        try:
+            filename = os.path.abspath(inspect.getsourcefile(func))
+        except:  # noqa: E722
+            filename = None
+        if filename is not None:
+            # mangling of full path to filename
+            parts = filename.split(os.sep)
+            if parts[-1].startswith("<ipython-input"):
+                # We're in a IPython (or notebook) session. parts[-1] comes
+                # from func.__code__.co_filename and is of the form
+                # <ipython-input-N-XYZ>, where:
+                # - N is the cell number where the function was defined
+                # - XYZ is a hash representing the function's code (and name).
+                #   It will be consistent across sessions and kernel restarts,
+                #   and will change if the function's code/name changes
+                # We remove N so that cache is properly hit if the cell where
+                # the func is defined is re-exectuted.
+                # The XYZ hash should avoid collisions between functions with
+                # the same name, both within the same notebook but also across
+                # notebooks
+                split = parts[-1].split("-")
+                parts[-1] = "-".join(split[:2] + split[3:])
+            elif len(parts) > 2 and parts[-2].startswith("ipykernel_"):
+                # In a notebook session (ipykernel). Filename seems to be 'xyz'
+                # of above. parts[-2] has the structure ipykernel_XXXXXX where
+                # XXXXXX is a six-digit number identifying the current run (?).
+                # If we split it off, the function again has the same
+                # identifier across runs.
+                parts[-2] = "ipykernel"
+            filename = "-".join(parts)
+            if filename.endswith(".py"):
+                filename = filename[:-3]
+            module = module + "-" + filename
+    module = module.split(".")
+    if hasattr(func, "func_name"):
+        name = func.func_name
+    elif hasattr(func, "__name__"):
+        name = func.__name__
+    else:
+        name = "unknown"
+    # Hack to detect functions not defined at the module-level
+    if resolv_alias:
+        # TODO: Maybe add a warning here?
+        if hasattr(func, "func_globals") and name in func.func_globals:
+            if func.func_globals[name] is not func:
+                name = "%s-alias" % name
+    if hasattr(func, "__qualname__") and func.__qualname__ != name:
+        # Extend the module name in case of nested functions to avoid
+        # (module, name) collisions
+        module.extend(func.__qualname__.split(".")[:-1])
+    if inspect.ismethod(func):
+        # We need to add the name of the class
+        if hasattr(func, "im_class"):
+            klass = func.im_class
+            module.append(klass.__name__)
+    if os.name == "nt" and win_characters:
+        # Windows can't encode certain characters in filenames
+        name = _clean_win_chars(name)
+        module = [_clean_win_chars(s) for s in module]
+    return module, name
+
+
+def _signature_str(function_name, arg_sig):
+    """Helper function to output a function signature"""
+    return "{}{}".format(function_name, arg_sig)
+
+
+def _function_called_str(function_name, args, kwargs):
+    """Helper function to output a function call"""
+    template_str = "{0}({1}, {2})"
+
+    args_str = repr(args)[1:-1]
+    kwargs_str = ", ".join("%s=%s" % (k, v) for k, v in kwargs.items())
+    return template_str.format(function_name, args_str, kwargs_str)
+
+
+def filter_args(func, ignore_lst, args=(), kwargs=dict()):
+    """Filters the given args and kwargs using a list of arguments to
+    ignore, and a function specification.
+
+    Parameters
+    ----------
+    func: callable
+        Function giving the argument specification
+    ignore_lst: list of strings
+        List of arguments to ignore (either a name of an argument
+        in the function spec, or '*', or '**')
+    *args: list
+        Positional arguments passed to the function.
+    **kwargs: dict
+        Keyword arguments passed to the function
+
+    Returns
+    -------
+    filtered_args: list
+        List of filtered positional and keyword arguments.
+    """
+    args = list(args)
+    if isinstance(ignore_lst, str):
+        # Catch a common mistake
+        raise ValueError(
+            "ignore_lst must be a list of parameters to ignore "
+            "%s (type %s) was given" % (ignore_lst, type(ignore_lst))
+        )
+    # Special case for functools.partial objects
+    if not inspect.ismethod(func) and not inspect.isfunction(func):
+        if ignore_lst:
+            warnings.warn(
+                "Cannot inspect object %s, ignore list will not work." % func,
+                stacklevel=2,
+            )
+        return {"*": args, "**": kwargs}
+    arg_sig = inspect.signature(func)
+    arg_names = []
+    arg_defaults = []
+    arg_kwonlyargs = []
+    arg_varargs = None
+    arg_varkw = None
+    for param in arg_sig.parameters.values():
+        if param.kind is param.POSITIONAL_OR_KEYWORD:
+            arg_names.append(param.name)
+        elif param.kind is param.KEYWORD_ONLY:
+            arg_names.append(param.name)
+            arg_kwonlyargs.append(param.name)
+        elif param.kind is param.VAR_POSITIONAL:
+            arg_varargs = param.name
+        elif param.kind is param.VAR_KEYWORD:
+            arg_varkw = param.name
+        if param.default is not param.empty:
+            arg_defaults.append(param.default)
+    if inspect.ismethod(func):
+        # First argument is 'self', it has been removed by Python
+        # we need to add it back:
+        args = [
+            func.__self__,
+        ] + args
+        # func is an instance method, inspect.signature(func) does not
+        # include self, we need to fetch it from the class method, i.e
+        # func.__func__
+        class_method_sig = inspect.signature(func.__func__)
+        self_name = next(iter(class_method_sig.parameters))
+        arg_names = [self_name] + arg_names
+    # XXX: Maybe I need an inspect.isbuiltin to detect C-level methods, such
+    # as on ndarrays.
+
+    _, name = get_func_name(func, resolv_alias=False)
+    arg_dict = dict()
+    arg_position = -1
+    for arg_position, arg_name in enumerate(arg_names):
+        if arg_position < len(args):
+            # Positional argument or keyword argument given as positional
+            if arg_name not in arg_kwonlyargs:
+                arg_dict[arg_name] = args[arg_position]
+            else:
+                raise ValueError(
+                    "Keyword-only parameter '%s' was passed as "
+                    "positional parameter for %s:\n"
+                    "     %s was called."
+                    % (
+                        arg_name,
+                        _signature_str(name, arg_sig),
+                        _function_called_str(name, args, kwargs),
+                    )
+                )
+
+        else:
+            position = arg_position - len(arg_names)
+            if arg_name in kwargs:
+                arg_dict[arg_name] = kwargs[arg_name]
+            else:
+                try:
+                    arg_dict[arg_name] = arg_defaults[position]
+                except (IndexError, KeyError) as e:
+                    # Missing argument
+                    raise ValueError(
+                        "Wrong number of arguments for %s:\n"
+                        "     %s was called."
+                        % (
+                            _signature_str(name, arg_sig),
+                            _function_called_str(name, args, kwargs),
+                        )
+                    ) from e
+
+    varkwargs = dict()
+    for arg_name, arg_value in sorted(kwargs.items()):
+        if arg_name in arg_dict:
+            arg_dict[arg_name] = arg_value
+        elif arg_varkw is not None:
+            varkwargs[arg_name] = arg_value
+        else:
+            raise TypeError(
+                "Ignore list for %s() contains an unexpected "
+                "keyword argument '%s'" % (name, arg_name)
+            )
+
+    if arg_varkw is not None:
+        arg_dict["**"] = varkwargs
+    if arg_varargs is not None:
+        varargs = args[arg_position + 1 :]
+        arg_dict["*"] = varargs
+
+    # Now remove the arguments to be ignored
+    for item in ignore_lst:
+        if item in arg_dict:
+            arg_dict.pop(item)
+        else:
+            raise ValueError(
+                "Ignore list: argument '%s' is not defined for "
+                "function %s" % (item, _signature_str(name, arg_sig))
+            )
+    # XXX: Return a sorted list of pairs?
+    return arg_dict
+
+
+def _format_arg(arg):
+    formatted_arg = pformat(arg, indent=2)
+    if len(formatted_arg) > 1500:
+        formatted_arg = "%s..." % formatted_arg[:700]
+    return formatted_arg
+
+
+def format_signature(func, *args, **kwargs):
+    # XXX: Should this use inspect.formatargvalues/formatargspec?
+    module, name = get_func_name(func)
+    module = [m for m in module if m]
+    if module:
+        module.append(name)
+        module_path = ".".join(module)
+    else:
+        module_path = name
+    arg_str = list()
+    previous_length = 0
+    for arg in args:
+        formatted_arg = _format_arg(arg)
+        if previous_length > 80:
+            formatted_arg = "\n%s" % formatted_arg
+        previous_length = len(formatted_arg)
+        arg_str.append(formatted_arg)
+    arg_str.extend(["%s=%s" % (v, _format_arg(i)) for v, i in kwargs.items()])
+    arg_str = ", ".join(arg_str)
+
+    signature = "%s(%s)" % (name, arg_str)
+    return module_path, signature
+
+
+def format_call(func, args, kwargs, object_name="Memory"):
+    """Returns a nicely formatted statement displaying the function
+    call with the given arguments.
+    """
+    path, signature = format_signature(func, *args, **kwargs)
+    msg = "%s\n[%s] Calling %s...\n%s" % (80 * "_", object_name, path, signature)
+    return msg
+    # XXX: Not using logging framework
+    # self.debug(msg)