debugpy 1.8.5__zip → 1.8.7__zip

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydev_bundle/fsnotify/__init__.py

@@ -1,4 +1,4 @@
-'''
+"""
 Sample usage to track changes in a thread.
 
     import threading
@@ -36,11 +36,10 @@ Sample usage to track changes in a thread.
 
 
 Note: changes are only reported for files (added/modified/deleted), not directories.
-'''
-import threading
+"""
 import sys
 from os.path import basename
-from _pydev_bundle import pydev_log
+from _pydev_bundle import pydev_log, _pydev_saved_modules
 from os import scandir
 
 try:
@@ -50,11 +49,12 @@ except:
     class IntEnum(object):
         pass
 
+
 import time
 
-__author__ = 'Fabio Zadrozny'
-__email__ = 'fabiofz@gmail.com'
-__version__ = '0.1.5'  # Version here and in setup.py
+__author__ = "Fabio Zadrozny"
+__email__ = "fabiofz@gmail.com"
+__version__ = "0.1.5"  # Version here and in setup.py
 
 
 class Change(IntEnum):
@@ -64,7 +64,6 @@ class Change(IntEnum):
 
 
 class _SingleVisitInfo(object):
-
     def __init__(self):
         self.count = 0
         self.visited_dirs = set()
@@ -73,18 +72,18 @@ class _SingleVisitInfo(object):
 
 
 class _PathWatcher(object):
-    '''
+    """
     Helper to watch a single path.
-    '''
+    """
 
-    def __init__(self, root_path, accept_directory, accept_file, single_visit_info, max_recursion_level, sleep_time=.0):
-        '''
+    def __init__(self, root_path, accept_directory, accept_file, single_visit_info, max_recursion_level, sleep_time=0.0):
+        """
         :type root_path: str
         :type accept_directory: Callback[str, bool]
         :type accept_file: Callback[str, bool]
         :type max_recursion_level: int
         :type sleep_time: float
-        '''
+        """
         self.accept_directory = accept_directory
         self.accept_file = accept_file
         self._max_recursion_level = max_recursion_level
@@ -95,7 +94,7 @@ class _PathWatcher(object):
         # Watcher.target_time_for_single_scan.
         self.sleep_time = sleep_time
 
-        self.sleep_at_elapsed = 1. / 30.
+        self.sleep_at_elapsed = 1.0 / 30.0
 
         # When created, do the initial snapshot right away!
         old_file_to_mtime = {}
@@ -124,7 +123,7 @@ class _PathWatcher(object):
                     dir_path = dir_path.decode(sys.getfilesystemencoding())
                 except UnicodeDecodeError:
                     try:
-                        dir_path = dir_path.decode('utf-8')
+                        dir_path = dir_path.decode("utf-8")
                     except UnicodeDecodeError:
                         return  # Ignore if we can't deal with the path.
 
@@ -167,10 +166,9 @@ class _PathWatcher(object):
 
 
 class Watcher(object):
-
     # By default (if accept_directory is not specified), these will be the
     # ignored directories.
-    ignored_dirs = {u'.git', u'__pycache__', u'.idea', u'node_modules', u'.metadata'}
+    ignored_dirs = {".git", "__pycache__", ".idea", "node_modules", ".metadata"}
 
     # By default (if accept_file is not specified), these will be the
     # accepted files.
@@ -195,7 +193,7 @@ class Watcher(object):
     max_recursion_level = 10
 
     def __init__(self, accept_directory=None, accept_file=None):
-        '''
+        """
         :param Callable[str, bool] accept_directory:
             Callable that returns whether a directory should be watched.
             Note: if passed it'll override the `ignored_dirs`
@@ -203,15 +201,14 @@ class Watcher(object):
         :param Callable[str, bool] accept_file:
             Callable that returns whether a file should be watched.
             Note: if passed it'll override the `accepted_file_extensions`.
-        '''
+        """
         self._path_watchers = set()
-        self._disposed = threading.Event()
+        self._disposed = _pydev_saved_modules.ThreadingEvent()
 
         if accept_directory is None:
             accept_directory = lambda dir_path: basename(dir_path) not in self.ignored_dirs
         if accept_file is None:
-            accept_file = lambda path_name: \
-                not self.accepted_file_extensions or path_name.endswith(self.accepted_file_extensions)
+            accept_file = lambda path_name: not self.accepted_file_extensions or path_name.endswith(self.accepted_file_extensions)
         self.accept_file = accept_file
         self.accept_directory = accept_directory
         self._single_visit_info = _SingleVisitInfo()
@@ -253,14 +250,14 @@ class Watcher(object):
         # Sort by the path len so that the bigger paths come first (so,
         # if there's any nesting we want the nested paths to be visited
         # before the parent paths so that the max_recursion_level is correct).
-        paths = sorted(set(paths), key=lambda path:-len(path))
+        paths = sorted(set(paths), key=lambda path: -len(path))
         path_watchers = set()
 
         self._single_visit_info = _SingleVisitInfo()
 
         initial_time = time.time()
         for path in paths:
-            sleep_time = 0.  # When collecting the first time, sleep_time should be 0!
+            sleep_time = 0.0  # When collecting the first time, sleep_time should be 0!
             path_watcher = _PathWatcher(
                 path,
                 self.accept_directory,
@@ -272,22 +269,22 @@ class Watcher(object):
 
             path_watchers.add(path_watcher)
 
-        actual_time = (time.time() - initial_time)
+        actual_time = time.time() - initial_time
 
-        pydev_log.debug('Tracking the following paths for changes: %s', paths)
-        pydev_log.debug('Time to track: %.2fs', actual_time)
-        pydev_log.debug('Folders found: %s', len(self._single_visit_info.visited_dirs))
-        pydev_log.debug('Files found: %s', len(self._single_visit_info.file_to_mtime))
+        pydev_log.debug("Tracking the following paths for changes: %s", paths)
+        pydev_log.debug("Time to track: %.2fs", actual_time)
+        pydev_log.debug("Folders found: %s", len(self._single_visit_info.visited_dirs))
+        pydev_log.debug("Files found: %s", len(self._single_visit_info.file_to_mtime))
         self._path_watchers = path_watchers
 
     def iter_changes(self):
-        '''
+        """
         Continuously provides changes (until dispose() is called).
 
         Changes provided are tuples with the Change enum and filesystem path.
 
         :rtype: Iterable[Tuple[Change, str]]
-        '''
+        """
         while not self._disposed.is_set():
             initial_time = time.time()
 
@@ -307,9 +304,9 @@ class Watcher(object):
             for change in changes:
                 yield change
 
-            actual_time = (time.time() - initial_time)
+            actual_time = time.time() - initial_time
             if self.print_poll_time:
-                print('--- Total poll time: %.3fs' % actual_time)
+                print("--- Total poll time: %.3fs" % actual_time)
 
             if actual_time > 0:
                 if self.target_time_for_single_scan <= 0.0:
@@ -322,8 +319,8 @@ class Watcher(object):
                     # direction).
                     # (to prevent from cases where the user puts the machine on sleep and
                     # values become too skewed).
-                    if perc > 2.:
-                        perc = 2.
+                    if perc > 2.0:
+                        perc = 2.0
                     elif perc < 0.5:
                         perc = 0.5
 
@@ -337,7 +334,7 @@ class Watcher(object):
                         # (to prevent from cases where the user puts the machine on sleep and
                         # values become too skewed).
                         diff_sleep_time = new_sleep_time - path_watcher.sleep_time
-                        path_watcher.sleep_time += (diff_sleep_time / (3.0 * len(self._path_watchers)))
+                        path_watcher.sleep_time += diff_sleep_time / (3.0 * len(self._path_watchers))
 
                         if actual_time > 0:
                             self._disposed.wait(actual_time)
@@ -348,6 +345,5 @@ class Watcher(object):
             # print('new sleep time: %s' % path_watcher.sleep_time)
 
             diff = self.target_time_for_notification - actual_time
-            if diff > 0.:
+            if diff > 0.0:
                 self._disposed.wait(diff)
-

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydev_bundle/pydev_console_utils.py

@@ -2,11 +2,10 @@ import os
 import sys
 import traceback
 from _pydev_bundle.pydev_imports import xmlrpclib, _queue, Exec
-from  _pydev_bundle._pydev_calltip_util import get_description
+from _pydev_bundle._pydev_calltip_util import get_description
 from _pydevd_bundle import pydevd_vars
 from _pydevd_bundle import pydevd_xml
-from _pydevd_bundle.pydevd_constants import (IS_JYTHON, NEXT_VALUE_SEPARATOR, get_global_debugger,
-    silence_warnings_decorator)
+from _pydevd_bundle.pydevd_constants import IS_JYTHON, NEXT_VALUE_SEPARATOR, get_global_debugger, silence_warnings_decorator
 from contextlib import contextmanager
 from _pydev_bundle import pydev_log
 from _pydevd_bundle.pydevd_utils import interrupt_main_thread
@@ -18,7 +17,6 @@ from io import StringIO
 # BaseStdIn
 # =======================================================================================================================
 class BaseStdIn:
-
     def __init__(self, original_stdin=sys.stdin, *args, **kwargs):
         try:
             self.encoding = sys.stdin.encoding
@@ -37,7 +35,7 @@ class BaseStdIn:
         # sys.stderr.write('Cannot readline out of the console evaluation\n') -- don't show anything
         # This could happen if the user had done input('enter number).<-- upon entering this, that message would appear,
         # which is not something we want.
-        return '\n'
+        return "\n"
 
     def write(self, *args, **kwargs):
         pass  # not available StdIn (but it can be expected to be in the stream interface)
@@ -67,9 +65,9 @@ class BaseStdIn:
 # StdIn
 # =======================================================================================================================
 class StdIn(BaseStdIn):
-    '''
-        Object to be added to stdin (to emulate it as non-blocking while the next line arrives)
-    '''
+    """
+    Object to be added to stdin (to emulate it as non-blocking while the next line arrives)
+    """
 
     def __init__(self, interpreter, host, client_port, original_stdin=sys.stdin):
         BaseStdIn.__init__(self, original_stdin)
@@ -80,36 +78,36 @@ class StdIn(BaseStdIn):
     def readline(self, *args, **kwargs):
         # Ok, callback into the client to get the new input
         try:
-            server = xmlrpclib.Server('http://%s:%s' % (self.host, self.client_port))
+            server = xmlrpclib.Server("http://%s:%s" % (self.host, self.client_port))
             requested_input = server.RequestInput()
             if not requested_input:
-                return '\n'  # Yes, a readline must return something (otherwise we can get an EOFError on the input() call).
+                return "\n"  # Yes, a readline must return something (otherwise we can get an EOFError on the input() call).
             else:
                 # readline should end with '\n' (not doing so makes IPython 5 remove the last *valid* character).
-                requested_input += '\n'
+                requested_input += "\n"
             return requested_input
         except KeyboardInterrupt:
             raise  # Let KeyboardInterrupt go through -- #PyDev-816: Interrupting infinite loop in the Interactive Console
         except:
-            return '\n'
+            return "\n"
 
     def close(self, *args, **kwargs):
         pass  # expected in StdIn
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # DebugConsoleStdIn
-#=======================================================================================================================
+# =======================================================================================================================
 class DebugConsoleStdIn(BaseStdIn):
-    '''
-        Object to be added to stdin (to emulate it as non-blocking while the next line arrives)
-    '''
+    """
+    Object to be added to stdin (to emulate it as non-blocking while the next line arrives)
+    """
 
     def __init__(self, py_db, original_stdin):
-        '''
+        """
         :param py_db:
             If None, get_global_debugger() is used.
-        '''
+        """
         BaseStdIn.__init__(self, original_stdin)
         self._py_db = py_db
         self._in_notification = 0
@@ -150,7 +148,6 @@ class DebugConsoleStdIn(BaseStdIn):
 
 
 class CodeFragment:
-
     def __init__(self, text, is_single_line=True):
         self.text = text
         self.is_single_line = is_single_line
@@ -165,7 +162,6 @@ class CodeFragment:
 # BaseInterpreterInterface
 # =======================================================================================================================
 class BaseInterpreterInterface:
-
     def __init__(self, mainThread, connect_status_queue=None):
         self.mainThread = mainThread
         self.interruptable = False
@@ -177,17 +173,18 @@ class BaseInterpreterInterface:
         self.init_mpl_modules_for_patching()
 
     def build_banner(self):
-        return 'print({0})\n'.format(repr(self.get_greeting_msg()))
+        return "print({0})\n".format(repr(self.get_greeting_msg()))
 
     def get_greeting_msg(self):
-        return 'PyDev console: starting.\n'
+        return "PyDev console: starting.\n"
 
     def init_mpl_modules_for_patching(self):
         from pydev_ipython.matplotlibtools import activate_matplotlib, activate_pylab, activate_pyplot
+
         self.mpl_modules_for_patching = {
             "matplotlib": lambda: activate_matplotlib(self.enableGui),
             "matplotlib.pyplot": activate_pyplot,
-            "pylab": activate_pylab
+            "pylab": activate_pylab,
         }
 
     def need_more_for_code(self, source):
@@ -195,10 +192,10 @@ class BaseInterpreterInterface:
 
         # Strangely even the IPython console is_complete said it was complete
         # even with a continuation char at the end.
-        if source.endswith('\\'):
+        if source.endswith("\\"):
             return True
 
-        if hasattr(self.interpreter, 'is_complete'):
+        if hasattr(self.interpreter, "is_complete"):
             return not self.interpreter.is_complete(source)
         try:
             # At this point, it should always be single.
@@ -209,8 +206,8 @@ class BaseInterpreterInterface:
             # (in a single line) don't work.
             # Note that it won't give an error and code will be None (so, it'll
             # use execMultipleLines in the next call in this case).
-            symbol = 'single'
-            code = self.interpreter.compile(source, '<input>', symbol)
+            symbol = "single"
+            code = self.interpreter.compile(source, "<input>", symbol)
         except (OverflowError, SyntaxError, ValueError):
             # Case 1
             return False
@@ -243,13 +240,13 @@ class BaseInterpreterInterface:
             original_in = sys.stdin
             try:
                 help = None
-                if 'pydoc' in sys.modules:
-                    pydoc = sys.modules['pydoc']  # Don't import it if it still is not there.
+                if "pydoc" in sys.modules:
+                    pydoc = sys.modules["pydoc"]  # Don't import it if it still is not there.
 
-                    if hasattr(pydoc, 'help'):
+                    if hasattr(pydoc, "help"):
                         # You never know how will the API be changed, so, let's code defensively here
                         help = pydoc.help
-                        if not hasattr(help, 'input'):
+                        if not hasattr(help, "input"):
                             help = None
             except:
                 # Just ignore any error here
@@ -270,18 +267,18 @@ class BaseInterpreterInterface:
                             help = None
                             if not self._input_error_printed:
                                 self._input_error_printed = True
-                                sys.stderr.write('\nError when trying to update pydoc.help.input\n')
-                                sys.stderr.write('(help() may not work -- please report this as a bug in the pydev bugtracker).\n\n')
+                                sys.stderr.write("\nError when trying to update pydoc.help.input\n")
+                                sys.stderr.write("(help() may not work -- please report this as a bug in the pydev bugtracker).\n\n")
                                 traceback.print_exc()
 
                     try:
                         self.start_exec()
-                        if hasattr(self, 'debugger'):
+                        if hasattr(self, "debugger"):
                             self.debugger.enable_tracing()
 
                         more = self.do_add_exec(code_fragment)
 
-                        if hasattr(self, 'debugger'):
+                        if hasattr(self, "debugger"):
                             self.debugger.disable_tracing()
 
                         self.finish_exec(more)
@@ -307,19 +304,19 @@ class BaseInterpreterInterface:
         return more
 
     def do_add_exec(self, codeFragment):
-        '''
+        """
         Subclasses should override.
 
         @return: more (True if more input is needed to complete the statement and False if the statement is complete).
-        '''
+        """
         raise NotImplementedError()
 
     def get_namespace(self):
-        '''
+        """
         Subclasses should override.
 
         @return: dict with namespace.
-        '''
+        """
         raise NotImplementedError()
 
     def __resolve_reference__(self, text):
@@ -328,7 +325,7 @@ class BaseInterpreterInterface:
         :type text: str
         """
         obj = None
-        if '.' not in text:
+        if "." not in text:
             try:
                 obj = self.get_namespace()[text]
             except KeyError:
@@ -336,22 +333,22 @@ class BaseInterpreterInterface:
 
             if obj is None:
                 try:
-                    obj = self.get_namespace()['__builtins__'][text]
+                    obj = self.get_namespace()["__builtins__"][text]
                 except:
                     pass
 
             if obj is None:
                 try:
-                    obj = getattr(self.get_namespace()['__builtins__'], text, None)
+                    obj = getattr(self.get_namespace()["__builtins__"], text, None)
                 except:
                     pass
 
         else:
             try:
-                last_dot = text.rindex('.')
+                last_dot = text.rindex(".")
                 parent_context = text[0:last_dot]
                 res = pydevd_vars.eval_in_context(parent_context, self.get_namespace(), self.get_namespace())
-                obj = getattr(res, text[last_dot + 1:])
+                obj = getattr(res, text[last_dot + 1 :])
             except:
                 pass
         return obj
@@ -360,10 +357,10 @@ class BaseInterpreterInterface:
         try:
             obj = self.__resolve_reference__(text)
             if obj is None:
-                return ''
+                return ""
             return get_description(obj)
         except:
-            return ''
+            return ""
 
     def do_exec_code(self, code, is_single_line):
         try:
@@ -385,7 +382,7 @@ class BaseInterpreterInterface:
     def execMultipleLines(self, lines):
         if IS_JYTHON:
             more = False
-            for line in lines.split('\n'):
+            for line in lines.split("\n"):
                 more = self.do_exec_code(line, True)
             return more
         else:
@@ -411,8 +408,8 @@ class BaseInterpreterInterface:
         self.interruptable = True
 
     def get_server(self):
-        if getattr(self, 'host', None) is not None:
-            return xmlrpclib.Server('http://%s:%s' % (self.host, self.client_port))
+        if getattr(self, "host", None) is not None:
+            return xmlrpclib.Server("http://%s:%s" % (self.host, self.client_port))
         else:
             return None
 
@@ -485,8 +482,8 @@ class BaseInterpreterInterface:
         var_objects = []
         vars = scope_attrs.split(NEXT_VALUE_SEPARATOR)
         for var_attrs in vars:
-            if '\t' in var_attrs:
-                name, attrs = var_attrs.split('\t', 1)
+            if "\t" in var_attrs:
+                name, attrs = var_attrs.split("\t", 1)
 
             else:
                 name = var_attrs
@@ -499,38 +496,39 @@ class BaseInterpreterInterface:
                 var_objects.append((var_object, name))
 
         from _pydevd_bundle.pydevd_comm import GetValueAsyncThreadConsole
-        py_db = getattr(self, 'debugger', None)
+
+        py_db = getattr(self, "debugger", None)
 
         if py_db is None:
             py_db = get_global_debugger()
 
         if py_db is None:
             from pydevd import PyDB
+
             py_db = PyDB()
 
         t = GetValueAsyncThreadConsole(py_db, self.get_server(), seq, var_objects)
         t.start()
 
     def changeVariable(self, attr, value):
-
         def do_change_variable():
-            Exec('%s=%s' % (attr, value), self.get_namespace(), self.get_namespace())
+            Exec("%s=%s" % (attr, value), self.get_namespace(), self.get_namespace())
 
         # Important: it has to be really enabled in the main thread, so, schedule
         # it to run in the main thread.
         self.exec_queue.put(do_change_variable)
 
     def connectToDebugger(self, debuggerPort, debugger_options=None):
-        '''
+        """
         Used to show console with variables connection.
         Mainly, monkey-patches things in the debugger structure so that the debugger protocol works.
-        '''
+        """
 
         if debugger_options is None:
             debugger_options = {}
         env_key = "PYDEVD_EXTRA_ENVS"
         if env_key in debugger_options:
-            for (env_name, value) in debugger_options[env_key].items():
+            for env_name, value in debugger_options[env_key].items():
                 existing_value = os.environ.get(env_name, None)
                 if existing_value:
                     os.environ[env_name] = "%s%c%s" % (existing_value, os.path.pathsep, value)
@@ -549,10 +547,11 @@ class BaseInterpreterInterface:
             except:
                 # This happens on Jython embedded in host eclipse
                 traceback.print_exc()
-                sys.stderr.write('pydevd is not available, cannot connect\n')
+                sys.stderr.write("pydevd is not available, cannot connect\n")
 
             from _pydevd_bundle.pydevd_constants import set_thread_id
             from _pydev_bundle import pydev_localhost
+
             set_thread_id(threading.current_thread(), "console_main")
 
             VIRTUAL_FRAME_ID = "1"  # matches PyStackFrameConsole.java
@@ -571,22 +570,23 @@ class BaseInterpreterInterface:
                 self.debugger.disable_tracing()
             except:
                 traceback.print_exc()
-                sys.stderr.write('Failed to connect to target debugger.\n')
+                sys.stderr.write("Failed to connect to target debugger.\n")
 
             # Register to process commands when idle
             self.debugrunning = False
             try:
                 import pydevconsole
+
                 pydevconsole.set_debug_hook(self.debugger.process_internal_commands)
             except:
                 traceback.print_exc()
-                sys.stderr.write('Version of Python does not support debuggable Interactive Console.\n')
+                sys.stderr.write("Version of Python does not support debuggable Interactive Console.\n")
 
         # Important: it has to be really enabled in the main thread, so, schedule
         # it to run in the main thread.
         self.exec_queue.put(do_connect_to_debugger)
 
-        return ('connect complete',)
+        return ("connect complete",)
 
     def handshake(self):
         if self.connect_status_queue is not None:
@@ -601,21 +601,23 @@ class BaseInterpreterInterface:
         return ("Hello eclipse",)
 
     def enableGui(self, guiname):
-        ''' Enable the GUI specified in guiname (see inputhook for list).
-            As with IPython, enabling multiple GUIs isn't an error, but
-            only the last one's main loop runs and it may not work
-        '''
+        """Enable the GUI specified in guiname (see inputhook for list).
+        As with IPython, enabling multiple GUIs isn't an error, but
+        only the last one's main loop runs and it may not work
+        """
 
         def do_enable_gui():
             from _pydev_bundle.pydev_versioncheck import versionok_for_gui
+
             if versionok_for_gui():
                 try:
                     from pydev_ipython.inputhook import enable_gui
+
                     enable_gui(guiname)
                 except:
                     sys.stderr.write("Failed to enable GUI event loop integration for '%s'\n" % guiname)
                     traceback.print_exc()
-            elif guiname not in ['none', '', None]:
+            elif guiname not in ["none", "", None]:
                 # Only print a warning if the guiname was going to do something
                 sys.stderr.write("PyDev console: Python version does not support GUI event loop integration for '%s'\n" % guiname)
             # Return value does not matter, so return back what was sent
@@ -633,7 +635,7 @@ class BaseInterpreterInterface:
 # FakeFrame
 # =======================================================================================================================
 class FakeFrame:
-    '''
+    """
     Used to show console with variables connection.
     A class to be used as a mock of a frame.
-    '''
+    """

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydev_bundle/pydev_import_hook.py

@@ -1,4 +1,3 @@
-
 import sys
 import traceback
 from types import ModuleType
@@ -8,7 +7,6 @@ import builtins
 
 
 class ImportHookManager(ModuleType):
-
     def __init__(self, name, system_import):
         ModuleType.__init__(self, name)
         self._system_import = system_import
@@ -35,6 +33,6 @@ class ImportHookManager(ModuleType):
         return module
 
 
-import_hook_manager = ImportHookManager(__name__ + '.import_hook', builtins.__import__)
+import_hook_manager = ImportHookManager(__name__ + ".import_hook", builtins.__import__)
 builtins.__import__ = import_hook_manager.do_import
 sys.modules[import_hook_manager.__name__] = import_hook_manager

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydev_bundle/pydev_imports.py

@@ -10,4 +10,3 @@ from _pydev_bundle._pydev_saved_modules import _queue
 from _pydevd_bundle.pydevd_exec2 import Exec
 
 from urllib.parse import quote, quote_plus, unquote_plus  # @UnresolvedImport
-