Add files using upload-large-folder tool

lib/python3.10/site-packages/debugpy/_vendored/__init__.py

@@ -0,0 +1,126 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+import contextlib
+from importlib import import_module
+import os
+import sys
+
+from . import _util
+
+
+VENDORED_ROOT = os.path.dirname(os.path.abspath(__file__))
+# TODO: Move the "pydevd" git submodule to the debugpy/_vendored directory
+# and then drop the following fallback.
+if "pydevd" not in os.listdir(VENDORED_ROOT):
+    VENDORED_ROOT = os.path.dirname(VENDORED_ROOT)
+
+
+def list_all(resolve=False):
+    """Return the list of vendored projects."""
+    # TODO: Derive from os.listdir(VENDORED_ROOT)?
+    projects = ["pydevd"]
+    if not resolve:
+        return projects
+    return [project_root(name) for name in projects]
+
+
+def project_root(project):
+    """Return the path the root dir of the vendored project.
+
+    If "project" is an empty string then the path prefix for vendored
+    projects (e.g. "debugpy/_vendored/") will be returned.
+    """
+    if not project:
+        project = ""
+    return os.path.join(VENDORED_ROOT, project)
+
+
+def iter_project_files(project, relative=False, **kwargs):
+    """Yield (dirname, basename, filename) for all files in the project."""
+    if relative:
+        with _util.cwd(VENDORED_ROOT):
+            for result in _util.iter_all_files(project, **kwargs):
+                yield result
+    else:
+        root = project_root(project)
+        for result in _util.iter_all_files(root, **kwargs):
+            yield result
+
+
+def iter_packaging_files(project):
+    """Yield the filenames for all files in the project.
+
+    The filenames are relative to "debugpy/_vendored".  This is most
+    useful for the "package data" in a setup.py.
+    """
+    # TODO: Use default filters?  __pycache__ and .pyc?
+    prune_dir = None
+    exclude_file = None
+    try:
+        mod = import_module("._{}_packaging".format(project), __name__)
+    except ImportError:
+        pass
+    else:
+        prune_dir = getattr(mod, "prune_dir", prune_dir)
+        exclude_file = getattr(mod, "exclude_file", exclude_file)
+    results = iter_project_files(
+        project, relative=True, prune_dir=prune_dir, exclude_file=exclude_file
+    )
+    for _, _, filename in results:
+        yield filename
+
+
+def prefix_matcher(*prefixes):
+    """Return a module match func that matches any of the given prefixes."""
+    assert prefixes
+
+    def match(name, module):
+        for prefix in prefixes:
+            if name.startswith(prefix):
+                return True
+        else:
+            return False
+
+    return match
+
+
+def check_modules(project, match, root=None):
+    """Verify that only vendored modules have been imported."""
+    if root is None:
+        root = project_root(project)
+    extensions = []
+    unvendored = {}
+    for modname, mod in list(sys.modules.items()):
+        if not match(modname, mod):
+            continue
+        try:
+            filename = getattr(mod, "__file__", None)
+        except:  # In theory it's possible that any error is raised when accessing __file__
+            filename = None
+        if not filename:  # extension module
+            extensions.append(modname)
+        elif not filename.startswith(root):
+            unvendored[modname] = filename
+    return unvendored, extensions
+
+
+@contextlib.contextmanager
+def vendored(project, root=None):
+    """A context manager under which the vendored project will be imported."""
+    if root is None:
+        root = project_root(project)
+    # Add the vendored project directory, so that it gets tried first.
+    sys.path.insert(0, root)
+    try:
+        yield root
+    finally:
+        sys.path.remove(root)
+
+
+def preimport(project, modules, **kwargs):
+    """Import each of the named modules out of the vendored project."""
+    with vendored(project, **kwargs):
+        for name in modules:
+            import_module(name)

lib/python3.10/site-packages/debugpy/_vendored/_pydevd_packaging.py

@@ -0,0 +1,48 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+from . import VENDORED_ROOT
+from ._util import cwd, iter_all_files
+
+
+INCLUDES = [
+    'setup_pydevd_cython.py',
+]
+
+
+def iter_files():
+    # From the root of pydevd repo, we want only scripts and
+    # subdirectories that constitute the package itself (not helper
+    # scripts, tests etc). But when walking down into those
+    # subdirectories, we want everything below.
+
+    with cwd(VENDORED_ROOT):
+        return iter_all_files('pydevd', prune_dir, exclude_file)
+
+
+def prune_dir(dirname, basename):
+    if basename == '__pycache__':
+        return True
+    elif dirname != 'pydevd':
+        return False
+    elif basename.startswith('pydev'):
+        return False
+    elif basename.startswith('_pydev'):
+        return False
+    return True
+
+
+def exclude_file(dirname, basename):
+    if dirname == 'pydevd':
+        if basename in INCLUDES:
+            return False
+        elif not basename.endswith('.py'):
+            return True
+        elif 'pydev' not in basename:
+            return True
+        return False
+
+    if basename.endswith('.pyc'):
+        return True
+    return False

lib/python3.10/site-packages/debugpy/_vendored/_util.py

@@ -0,0 +1,59 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+import contextlib
+import os
+
+
+@contextlib.contextmanager
+def cwd(dirname):
+    """A context manager for operating in a different directory."""
+    orig = os.getcwd()
+    os.chdir(dirname)
+    try:
+        yield orig
+    finally:
+        os.chdir(orig)
+
+
+def iter_all_files(root, prune_dir=None, exclude_file=None):
+    """Yield (dirname, basename, filename) for each file in the tree.
+
+    This is an alternative to os.walk() that flattens out the tree and
+    with filtering.
+    """
+    pending = [root]
+    while pending:
+        dirname = pending.pop(0)
+        for result in _iter_files(dirname, pending, prune_dir, exclude_file):
+            yield result
+
+
+def iter_tree(root, prune_dir=None, exclude_file=None):
+    """Yield (dirname, files) for each directory in the tree.
+
+    The list of files is actually a list of (basename, filename).
+
+    This is an alternative to os.walk() with filtering."""
+    pending = [root]
+    while pending:
+        dirname = pending.pop(0)
+        files = []
+        for _, b, f in _iter_files(dirname, pending, prune_dir, exclude_file):
+            files.append((b, f))
+        yield dirname, files
+
+
+def _iter_files(dirname, subdirs, prune_dir, exclude_file):
+    for basename in os.listdir(dirname):
+        filename = os.path.join(dirname, basename)
+        if os.path.isdir(filename):
+            if prune_dir is not None and prune_dir(dirname, basename):
+                continue
+            subdirs.append(filename)
+        else:
+            # TODO: Use os.path.isfile() to narrow it down?
+            if exclude_file is not None and exclude_file(dirname, basename):
+                continue
+            yield dirname, basename, filename

lib/python3.10/site-packages/debugpy/_vendored/force_pydevd.py

@@ -0,0 +1,81 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+from importlib import import_module
+import os
+import warnings
+
+from . import check_modules, prefix_matcher, preimport, vendored
+
+# Ensure that pydevd is our vendored copy.
+_unvendored, _ = check_modules('pydevd',
+                               prefix_matcher('pydev', '_pydev'))
+if _unvendored:
+    _unvendored = sorted(_unvendored.values())
+    msg = 'incompatible copy of pydevd already imported'
+    # raise ImportError(msg)
+    warnings.warn(msg + ':\n {}'.format('\n  '.join(_unvendored)))
+
+# If debugpy logging is enabled, enable it for pydevd as well
+if "DEBUGPY_LOG_DIR" in os.environ:
+    os.environ[str("PYDEVD_DEBUG")] = str("True")
+    os.environ[str("PYDEVD_DEBUG_FILE")] = os.environ["DEBUGPY_LOG_DIR"] + str("/debugpy.pydevd.log")
+
+# Disable pydevd frame-eval optimizations only if unset, to allow opt-in.
+if "PYDEVD_USE_FRAME_EVAL" not in os.environ:
+    os.environ[str("PYDEVD_USE_FRAME_EVAL")] = str("NO")
+
+# Constants must be set before importing any other pydevd module
+# # due to heavy use of "from" in them.
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", category=DeprecationWarning)
+    with vendored('pydevd'):
+        pydevd_constants = import_module('_pydevd_bundle.pydevd_constants')
+# We limit representation size in our representation provider when needed.
+pydevd_constants.MAXIMUM_VARIABLE_REPRESENTATION_SIZE = 2 ** 32
+
+# Now make sure all the top-level modules and packages in pydevd are
+# loaded.  Any pydevd modules that aren't loaded at this point, will
+# be loaded using their parent package's __path__ (i.e. one of the
+# following).
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", category=DeprecationWarning)
+    preimport('pydevd', [
+        '_pydev_bundle',
+        '_pydev_runfiles',
+        '_pydevd_bundle',
+        '_pydevd_frame_eval',
+        'pydev_ipython',
+        'pydevd_plugins',
+        'pydevd',
+    ])
+
+# When pydevd is imported it sets the breakpoint behavior, but it needs to be
+# overridden because by default pydevd will connect to the remote debugger using
+# its own custom protocol rather than DAP.
+import pydevd  # noqa
+import debugpy  # noqa
+
+
+def debugpy_breakpointhook():
+    debugpy.breakpoint()
+
+
+pydevd.install_breakpointhook(debugpy_breakpointhook)
+
+# Ensure that pydevd uses JSON protocol
+from _pydevd_bundle import pydevd_constants
+from _pydevd_bundle import pydevd_defaults
+pydevd_defaults.PydevdCustomization.DEFAULT_PROTOCOL = pydevd_constants.HTTP_JSON_PROTOCOL
+
+# Enable some defaults related to debugpy such as sending a single notification when
+# threads pause and stopping on any exception.
+pydevd_defaults.PydevdCustomization.DEBUG_MODE = 'debugpy-dap'
+
+# This is important when pydevd attaches automatically to a subprocess. In this case, we have to
+# make sure that debugpy is properly put back in the game for users to be able to use it.
+pydevd_defaults.PydevdCustomization.PREIMPORT = '%s;%s' % (
+    os.path.dirname(os.path.dirname(debugpy.__file__)), 
+    'debugpy._vendored.force_pydevd'
+)

lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_calltip_util.py

@@ -0,0 +1,153 @@
+"""
+License: Apache 2.0
+Author: Yuli Fitterman
+"""
+import types
+
+from _pydevd_bundle.pydevd_constants import IS_JYTHON
+
+try:
+    import inspect
+except:
+    import traceback
+
+    traceback.print_exc()  # Ok, no inspect available (search will not work)
+
+from _pydev_bundle._pydev_imports_tipper import signature_from_docstring
+
+
+def is_bound_method(obj):
+    if isinstance(obj, types.MethodType):
+        return getattr(obj, "__self__", getattr(obj, "im_self", None)) is not None
+    else:
+        return False
+
+
+def get_class_name(instance):
+    return getattr(getattr(instance, "__class__", None), "__name__", None)
+
+
+def get_bound_class_name(obj):
+    my_self = getattr(obj, "__self__", getattr(obj, "im_self", None))
+    if my_self is None:
+        return None
+    return get_class_name(my_self)
+
+
+def get_description(obj):
+    try:
+        ob_call = obj.__call__
+    except:
+        ob_call = None
+
+    if isinstance(obj, type) or type(obj).__name__ == "classobj":
+        fob = getattr(obj, "__init__", lambda: None)
+        if not isinstance(fob, (types.FunctionType, types.MethodType)):
+            fob = obj
+    elif is_bound_method(ob_call):
+        fob = ob_call
+    else:
+        fob = obj
+
+    argspec = ""
+    fn_name = None
+    fn_class = None
+    if isinstance(fob, (types.FunctionType, types.MethodType)):
+        spec_info = inspect.getfullargspec(fob)
+        argspec = inspect.formatargspec(*spec_info)
+        fn_name = getattr(fob, "__name__", None)
+        if isinstance(obj, type) or type(obj).__name__ == "classobj":
+            fn_name = "__init__"
+            fn_class = getattr(obj, "__name__", "UnknownClass")
+        elif is_bound_method(obj) or is_bound_method(ob_call):
+            fn_class = get_bound_class_name(obj) or "UnknownClass"
+
+    else:
+        fn_name = getattr(fob, "__name__", None)
+        fn_self = getattr(fob, "__self__", None)
+        if fn_self is not None and not isinstance(fn_self, types.ModuleType):
+            fn_class = get_class_name(fn_self)
+
+    doc_string = get_docstring(ob_call) if is_bound_method(ob_call) else get_docstring(obj)
+    return create_method_stub(fn_name, fn_class, argspec, doc_string)
+
+
+def create_method_stub(fn_name, fn_class, argspec, doc_string):
+    if fn_name and argspec:
+        doc_string = "" if doc_string is None else doc_string
+        fn_stub = create_function_stub(fn_name, argspec, doc_string, indent=1 if fn_class else 0)
+        if fn_class:
+            expr = fn_class if fn_name == "__init__" else fn_class + "()." + fn_name
+            return create_class_stub(fn_class, fn_stub) + "\n" + expr
+        else:
+            expr = fn_name
+            return fn_stub + "\n" + expr
+    elif doc_string:
+        if fn_name:
+            restored_signature, _ = signature_from_docstring(doc_string, fn_name)
+            if restored_signature:
+                return create_method_stub(fn_name, fn_class, restored_signature, doc_string)
+        return create_function_stub("unknown", "(*args, **kwargs)", doc_string) + "\nunknown"
+
+    else:
+        return ""
+
+
+def get_docstring(obj):
+    if obj is not None:
+        try:
+            if IS_JYTHON:
+                # Jython
+                doc = obj.__doc__
+                if doc is not None:
+                    return doc
+
+                from _pydev_bundle import _pydev_jy_imports_tipper
+
+                is_method, infos = _pydev_jy_imports_tipper.ismethod(obj)
+                ret = ""
+                if is_method:
+                    for info in infos:
+                        ret += info.get_as_doc()
+                    return ret
+
+            else:
+                doc = inspect.getdoc(obj)
+                if doc is not None:
+                    return doc
+        except:
+            pass
+    else:
+        return ""
+    try:
+        # if no attempt succeeded, try to return repr()...
+        return repr(obj)
+    except:
+        try:
+            # otherwise the class
+            return str(obj.__class__)
+        except:
+            # if all fails, go to an empty string
+            return ""
+
+
+def create_class_stub(class_name, contents):
+    return "class %s(object):\n%s" % (class_name, contents)
+
+
+def create_function_stub(fn_name, fn_argspec, fn_docstring, indent=0):
+    def shift_right(string, prefix):
+        return "".join(prefix + line for line in string.splitlines(True))
+
+    fn_docstring = shift_right(inspect.cleandoc(fn_docstring), "  " * (indent + 1))
+    ret = '''
+def %s%s:
+    """%s"""
+    pass
+''' % (fn_name, fn_argspec, fn_docstring)
+    ret = ret[1:]  # remove first /n
+    ret = ret.replace("\t", "  ")
+    if indent:
+        prefix = "  " * indent
+        ret = shift_right(ret, prefix)
+    return ret

lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_completer.py

@@ -0,0 +1,267 @@
+from collections import namedtuple
+from string import ascii_letters, digits
+
+from _pydevd_bundle import pydevd_xml
+import pydevconsole
+
+import builtins as __builtin__  # Py3
+
+try:
+    import java.lang  # @UnusedImport
+    from _pydev_bundle import _pydev_jy_imports_tipper
+
+    _pydev_imports_tipper = _pydev_jy_imports_tipper
+except ImportError:
+    IS_JYTHON = False
+    from _pydev_bundle import _pydev_imports_tipper
+
+dir2 = _pydev_imports_tipper.generate_imports_tip_for_module
+
+
+# =======================================================================================================================
+# _StartsWithFilter
+# =======================================================================================================================
+class _StartsWithFilter:
+    """
+    Used because we can't create a lambda that'll use an outer scope in jython 2.1
+    """
+
+    def __init__(self, start_with):
+        self.start_with = start_with.lower()
+
+    def __call__(self, name):
+        return name.lower().startswith(self.start_with)
+
+
+# =======================================================================================================================
+# Completer
+#
+# This class was gotten from IPython.completer (dir2 was replaced with the completer already in pydev)
+# =======================================================================================================================
+class Completer:
+    def __init__(self, namespace=None, global_namespace=None):
+        """Create a new completer for the command line.
+
+        Completer([namespace,global_namespace]) -> completer instance.
+
+        If unspecified, the default namespace where completions are performed
+        is __main__ (technically, __main__.__dict__). Namespaces should be
+        given as dictionaries.
+
+        An optional second namespace can be given.  This allows the completer
+        to handle cases where both the local and global scopes need to be
+        distinguished.
+
+        Completer instances should be used as the completion mechanism of
+        readline via the set_completer() call:
+
+        readline.set_completer(Completer(my_namespace).complete)
+        """
+
+        # Don't bind to namespace quite yet, but flag whether the user wants a
+        # specific namespace or to use __main__.__dict__. This will allow us
+        # to bind to __main__.__dict__ at completion time, not now.
+        if namespace is None:
+            self.use_main_ns = 1
+        else:
+            self.use_main_ns = 0
+            self.namespace = namespace
+
+        # The global namespace, if given, can be bound directly
+        if global_namespace is None:
+            self.global_namespace = {}
+        else:
+            self.global_namespace = global_namespace
+
+    def complete(self, text):
+        """Return the next possible completion for 'text'.
+
+        This is called successively with state == 0, 1, 2, ... until it
+        returns None.  The completion should begin with 'text'.
+
+        """
+        if self.use_main_ns:
+            # In pydev this option should never be used
+            raise RuntimeError("Namespace must be provided!")
+            self.namespace = __main__.__dict__  # @UndefinedVariable
+
+        if "." in text:
+            return self.attr_matches(text)
+        else:
+            return self.global_matches(text)
+
+    def global_matches(self, text):
+        """Compute matches when text is a simple name.
+
+        Return a list of all keywords, built-in functions and names currently
+        defined in self.namespace or self.global_namespace that match.
+
+        """
+
+        def get_item(obj, attr):
+            return obj[attr]
+
+        a = {}
+
+        for dict_with_comps in [__builtin__.__dict__, self.namespace, self.global_namespace]:  # @UndefinedVariable
+            a.update(dict_with_comps)
+
+        filter = _StartsWithFilter(text)
+
+        return dir2(a, a.keys(), get_item, filter)
+
+    def attr_matches(self, text):
+        """Compute matches when text contains a dot.
+
+        Assuming the text is of the form NAME.NAME....[NAME], and is
+        evaluatable in self.namespace or self.global_namespace, it will be
+        evaluated and its attributes (as revealed by dir()) are used as
+        possible completions.  (For class instances, class members are are
+        also considered.)
+
+        WARNING: this can still invoke arbitrary C code, if an object
+        with a __getattr__ hook is evaluated.
+
+        """
+        import re
+
+        # Another option, seems to work great. Catches things like ''.<tab>
+        m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)  # @UndefinedVariable
+
+        if not m:
+            return []
+
+        expr, attr = m.group(1, 3)
+        try:
+            obj = eval(expr, self.namespace)
+        except:
+            try:
+                obj = eval(expr, self.global_namespace)
+            except:
+                return []
+
+        filter = _StartsWithFilter(attr)
+
+        words = dir2(obj, filter=filter)
+
+        return words
+
+
+def generate_completions(frame, act_tok):
+    """
+    :return list(tuple(method_name, docstring, parameters, completion_type))
+
+    method_name: str
+    docstring: str
+    parameters: str -- i.e.: "(a, b)"
+    completion_type is an int
+        See: _pydev_bundle._pydev_imports_tipper for TYPE_ constants
+    """
+    if frame is None:
+        return []
+
+    # Not using frame.f_globals because of https://sourceforge.net/tracker2/?func=detail&aid=2541355&group_id=85796&atid=577329
+    # (Names not resolved in generator expression in method)
+    # See message: http://mail.python.org/pipermail/python-list/2009-January/526522.html
+    updated_globals = {}
+    updated_globals.update(frame.f_globals)
+    updated_globals.update(frame.f_locals)  # locals later because it has precedence over the actual globals
+
+    if pydevconsole.IPYTHON:
+        completions = pydevconsole.get_completions(act_tok, act_tok, updated_globals, frame.f_locals)
+    else:
+        completer = Completer(updated_globals, None)
+        # list(tuple(name, descr, parameters, type))
+        completions = completer.complete(act_tok)
+
+    return completions
+
+
+def generate_completions_as_xml(frame, act_tok):
+    completions = generate_completions(frame, act_tok)
+    return completions_to_xml(completions)
+
+
+def completions_to_xml(completions):
+    valid_xml = pydevd_xml.make_valid_xml_value
+    quote = pydevd_xml.quote
+    msg = ["<xml>"]
+
+    for comp in completions:
+        msg.append('<comp p0="')
+        msg.append(valid_xml(quote(comp[0], "/>_= \t")))
+        msg.append('" p1="')
+        msg.append(valid_xml(quote(comp[1], "/>_= \t")))
+        msg.append('" p2="')
+        msg.append(valid_xml(quote(comp[2], "/>_= \t")))
+        msg.append('" p3="')
+        msg.append(valid_xml(quote(comp[3], "/>_= \t")))
+        msg.append('"/>')
+    msg.append("</xml>")
+
+    return "".join(msg)
+
+
+identifier_start = ascii_letters + "_"
+identifier_part = ascii_letters + "_" + digits
+
+identifier_start = set(identifier_start)
+identifier_part = set(identifier_part)
+
+
+def isidentifier(s):
+    return s.isidentifier()
+
+
+TokenAndQualifier = namedtuple("TokenAndQualifier", "token, qualifier")
+
+
+def extract_token_and_qualifier(text, line=0, column=0):
+    """
+    Extracts the token a qualifier from the text given the line/colum
+    (see test_extract_token_and_qualifier for examples).
+
+    :param unicode text:
+    :param int line: 0-based
+    :param int column: 0-based
+    """
+    # Note: not using the tokenize module because text should be unicode and
+    # line/column refer to the unicode text (otherwise we'd have to know
+    # those ranges after converted to bytes).
+    if line < 0:
+        line = 0
+    if column < 0:
+        column = 0
+
+    if isinstance(text, bytes):
+        text = text.decode("utf-8")
+
+    lines = text.splitlines()
+    try:
+        text = lines[line]
+    except IndexError:
+        return TokenAndQualifier("", "")
+
+    if column >= len(text):
+        column = len(text)
+
+    text = text[:column]
+    token = ""
+    qualifier = ""
+
+    temp_token = []
+    for i in range(column - 1, -1, -1):
+        c = text[i]
+        if c in identifier_part or isidentifier(c) or c == ".":
+            temp_token.append(c)
+        else:
+            break
+    temp_token = "".join(reversed(temp_token))
+    if "." in temp_token:
+        temp_token = temp_token.split(".")
+        token = ".".join(temp_token[:-1])
+        qualifier = temp_token[-1]
+    else:
+        qualifier = temp_token
+
+    return TokenAndQualifier(token, qualifier)

lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_execfile.py

@@ -0,0 +1,16 @@
+# We must redefine it in Py3k if it's not already there
+def execfile(file, glob=None, loc=None):
+    if glob is None:
+        import sys
+
+        glob = sys._getframe().f_back.f_globals
+    if loc is None:
+        loc = glob
+
+    import tokenize
+
+    with tokenize.open(file) as stream:
+        contents = stream.read()
+
+    # execute the script (note: it's important to compile first to have the filename set in debug mode)
+    exec(compile(contents + "\n", file, "exec"), glob, loc)