debugpy 1.8.5__zip → 1.8.7__zip

debugpy-1.8.7/src/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_coverage.py

@@ -0,0 +1,77 @@
+import os.path
+import sys
+from _pydevd_bundle.pydevd_constants import Null
+
+
+# =======================================================================================================================
+# get_coverage_files
+# =======================================================================================================================
+def get_coverage_files(coverage_output_dir, number_of_files):
+    base_dir = coverage_output_dir
+    ret = []
+    i = 0
+    while len(ret) < number_of_files:
+        while True:
+            f = os.path.join(base_dir, ".coverage.%s" % i)
+            i += 1
+            if not os.path.exists(f):
+                ret.append(f)
+                break  # Break only inner for.
+    return ret
+
+
+# =======================================================================================================================
+# start_coverage_support
+# =======================================================================================================================
+def start_coverage_support(configuration):
+    return start_coverage_support_from_params(
+        configuration.coverage_output_dir,
+        configuration.coverage_output_file,
+        configuration.jobs,
+        configuration.coverage_include,
+    )
+
+
+# =======================================================================================================================
+# start_coverage_support_from_params
+# =======================================================================================================================
+def start_coverage_support_from_params(coverage_output_dir, coverage_output_file, jobs, coverage_include):
+    coverage_files = []
+    coverage_instance = Null()
+    if coverage_output_dir or coverage_output_file:
+        try:
+            import coverage  # @UnresolvedImport
+        except:
+            sys.stderr.write("Error: coverage module could not be imported\n")
+            sys.stderr.write("Please make sure that the coverage module (http://nedbatchelder.com/code/coverage/)\n")
+            sys.stderr.write("is properly installed in your interpreter: %s\n" % (sys.executable,))
+
+            import traceback
+
+            traceback.print_exc()
+        else:
+            if coverage_output_dir:
+                if not os.path.exists(coverage_output_dir):
+                    sys.stderr.write("Error: directory for coverage output (%s) does not exist.\n" % (coverage_output_dir,))
+
+                elif not os.path.isdir(coverage_output_dir):
+                    sys.stderr.write("Error: expected (%s) to be a directory.\n" % (coverage_output_dir,))
+
+                else:
+                    n = jobs
+                    if n <= 0:
+                        n += 1
+                    n += 1  # Add 1 more for the current process (which will do the initial import).
+                    coverage_files = get_coverage_files(coverage_output_dir, n)
+                    os.environ["COVERAGE_FILE"] = coverage_files.pop(0)
+
+                    coverage_instance = coverage.coverage(source=[coverage_include])
+                    coverage_instance.start()
+
+            elif coverage_output_file:
+                # Client of parallel run.
+                os.environ["COVERAGE_FILE"] = coverage_output_file
+                coverage_instance = coverage.coverage(source=[coverage_include])
+                coverage_instance.start()
+
+    return coverage_files, coverage_instance

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_nose.py

@@ -9,11 +9,10 @@ from io import StringIO
 import traceback
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # PydevPlugin
-#=======================================================================================================================
+# =======================================================================================================================
 class PydevPlugin(Plugin):
-
     def __init__(self, configuration):
         self.configuration = configuration
         Plugin.__init__(self)
@@ -28,13 +27,13 @@ class PydevPlugin(Plugin):
         self.coverage.stop()
         self.coverage.save()
 
-        pydev_runfiles_xml_rpc.notifyTestRunFinished('Finished in: %.2f secs.' % (time.time() - self.start_time,))
+        pydev_runfiles_xml_rpc.notifyTestRunFinished("Finished in: %.2f secs." % (time.time() - self.start_time,))
 
-    #===================================================================================================================
+    # ===================================================================================================================
     # Methods below are not called with multiprocess (so, we monkey-patch MultiProcessTestRunner.consolidate
     # so that they're called, but unfortunately we loose some info -- i.e.: the time for each test in this
     # process).
-    #===================================================================================================================
+    # ===================================================================================================================
 
     class Sentinel(object):
         pass
@@ -46,8 +45,8 @@ class PydevPlugin(Plugin):
         user_address = self.Sentinel
         user_class_address = self.Sentinel
         try:
-            if 'address' in user_test_instance.__dict__:
-                user_address = user_test_instance.__dict__.pop('address')
+            if "address" in user_test_instance.__dict__:
+                user_address = user_test_instance.__dict__.pop("address")
         except:
             # Just ignore anything here.
             pass
@@ -62,14 +61,14 @@ class PydevPlugin(Plugin):
             yield
         finally:
             if user_address is not self.Sentinel:
-                user_test_instance.__dict__['address'] = user_address
+                user_test_instance.__dict__["address"] = user_address
 
             if user_class_address is not self.Sentinel:
                 user_test_instance.__class__.address = user_class_address
 
     def _get_test_address(self, test):
         try:
-            if hasattr(test, 'address'):
+            if hasattr(test, "address"):
                 with self._without_user_address(test):
                     address = test.address()
 
@@ -86,30 +85,30 @@ class PydevPlugin(Plugin):
                 except TypeError:
                     # It may be an error at setup, in which case it's not really a test, but a Context object.
                     f = test.context.__file__
-                    if f.endswith('.pyc'):
+                    if f.endswith(".pyc"):
                         f = f[:-1]
-                    elif f.endswith('$py.class'):
-                        f = f[:-len('$py.class')] + '.py'
-                    address = f, '?'
+                    elif f.endswith("$py.class"):
+                        f = f[: -len("$py.class")] + ".py"
+                    address = f, "?"
         except:
             sys.stderr.write("PyDev: Internal pydev error getting test address. Please report at the pydev bug tracker\n")
             traceback.print_exc()
             sys.stderr.write("\n\n\n")
-            address = '?', '?'
+            address = "?", "?"
         return address
 
-    def report_cond(self, cond, test, captured_output, error=''):
-        '''
+    def report_cond(self, cond, test, captured_output, error=""):
+        """
         @param cond: fail, error, ok
-        '''
+        """
 
         address = self._get_test_address(test)
 
         error_contents = self.get_io_from_error(error)
         try:
-            time_str = '%.2f' % (time.time() - test._pydev_start_time)
+            time_str = "%.2f" % (time.time() - test._pydev_start_time)
         except:
-            time_str = '?'
+            time_str = "?"
 
         pydev_runfiles_xml_rpc.notifyTest(cond, captured_output, error_contents, address[0], address[1], time_str)
 
@@ -132,13 +131,13 @@ class PydevPlugin(Plugin):
         return err
 
     def get_captured_output(self, test):
-        if hasattr(test, 'capturedOutput') and test.capturedOutput:
+        if hasattr(test, "capturedOutput") and test.capturedOutput:
             return test.capturedOutput
-        return ''
+        return ""
 
     def addError(self, test, err):
         self.report_cond(
-            'error',
+            "error",
             test,
             self.get_captured_output(test),
             err,
@@ -146,7 +145,7 @@ class PydevPlugin(Plugin):
 
     def addFailure(self, test, err):
         self.report_cond(
-            'fail',
+            "fail",
             test,
             self.get_captured_output(test),
             err,
@@ -154,10 +153,10 @@ class PydevPlugin(Plugin):
 
     def addSuccess(self, test):
         self.report_cond(
-            'ok',
+            "ok",
             test,
             self.get_captured_output(test),
-            '',
+            "",
         )
 
 
@@ -173,33 +172,33 @@ def start_pydev_nose_plugin_singleton(configuration):
 original = MultiProcessTestRunner.consolidate
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # new_consolidate
-#=======================================================================================================================
+# =======================================================================================================================
 def new_consolidate(self, result, batch_result):
-    '''
+    """
     Used so that it can work with the multiprocess plugin.
     Monkeypatched because nose seems a bit unsupported at this time (ideally
     the plugin would have this support by default).
-    '''
+    """
     ret = original(self, result, batch_result)
 
     parent_frame = sys._getframe().f_back
     # addr is something as D:\pytesting1\src\mod1\hello.py:TestCase.testMet4
     # so, convert it to what report_cond expects
-    addr = parent_frame.f_locals['addr']
-    i = addr.rindex(':')
-    addr = [addr[:i], addr[i + 1:]]
+    addr = parent_frame.f_locals["addr"]
+    i = addr.rindex(":")
+    addr = [addr[:i], addr[i + 1 :]]
 
     output, testsRun, failures, errors, errorClasses = batch_result
     if failures or errors:
         for failure in failures:
-            PYDEV_NOSE_PLUGIN_SINGLETON.report_cond('fail', addr, output, failure)
+            PYDEV_NOSE_PLUGIN_SINGLETON.report_cond("fail", addr, output, failure)
 
         for error in errors:
-            PYDEV_NOSE_PLUGIN_SINGLETON.report_cond('error', addr, output, error)
+            PYDEV_NOSE_PLUGIN_SINGLETON.report_cond("error", addr, output, error)
     else:
-        PYDEV_NOSE_PLUGIN_SINGLETON.report_cond('ok', addr, output)
+        PYDEV_NOSE_PLUGIN_SINGLETON.report_cond("ok", addr, output)
 
     return ret
 

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_parallel.py

@@ -8,9 +8,9 @@ import threading
 import sys
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # flatten_test_suite
-#=======================================================================================================================
+# =======================================================================================================================
 def flatten_test_suite(test_suite, ret):
     if isinstance(test_suite, unittest.TestSuite):
         for t in test_suite._tests:
@@ -20,11 +20,11 @@ def flatten_test_suite(test_suite, ret):
         ret.append(test_suite)
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # execute_tests_in_parallel
-#=======================================================================================================================
+# =======================================================================================================================
 def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, coverage_include):
-    '''
+    """
     @param tests: list(PydevTestSuite)
         A list with the suites to be run
 
@@ -44,9 +44,10 @@ def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, cov
         run.
 
         It may also return False if in debug mode (in which case, multi-processes are not accepted)
-    '''
+    """
     try:
         from _pydevd_bundle.pydevd_comm import get_global_debugger
+
         if get_global_debugger() is not None:
             return False
     except:
@@ -58,7 +59,7 @@ def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, cov
     tests_queue = []
 
     queue_elements = []
-    if split == 'module':
+    if split == "module":
         module_to_tests = {}
         for test in tests:
             lst = []
@@ -74,7 +75,7 @@ def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, cov
             # Don't create jobs we will never use.
             jobs = len(queue_elements)
 
-    elif split == 'tests':
+    elif split == "tests":
         for test in tests:
             lst = []
             flatten_test_suite(test, lst)
@@ -86,7 +87,7 @@ def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, cov
             jobs = len(queue_elements)
 
     else:
-        raise AssertionError('Do not know how to handle: %s' % (split,))
+        raise AssertionError("Do not know how to handle: %s" % (split,))
 
     for test_cases in queue_elements:
         test_queue_elements = []
@@ -97,14 +98,14 @@ def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, cov
                 # Support for jython 2.1 (__testMethodName is pseudo-private in the test case)
                 test_name = test_case.__class__.__name__ + "." + test_case._TestCase__testMethodName
 
-            test_queue_elements.append(test_case.__pydev_pyfile__ + '|' + test_name)
+            test_queue_elements.append(test_case.__pydev_pyfile__ + "|" + test_name)
 
         tests_queue.append(test_queue_elements)
 
     if jobs < 2:
         return False
 
-    sys.stdout.write('Running tests in parallel with: %s jobs.\n' % (jobs,))
+    sys.stdout.write("Running tests in parallel with: %s jobs.\n" % (jobs,))
 
     queue = Queue.Queue()
     for item in tests_queue:
@@ -134,7 +135,7 @@ def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, cov
             # Wait for all the clients to exit.
             if not client.finished:
                 client_alive = True
-                time.sleep(.2)
+                time.sleep(0.2)
                 break
 
     for provider in providers:
@@ -143,11 +144,10 @@ def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, cov
     return True
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # CommunicationThread
-#=======================================================================================================================
+# =======================================================================================================================
 class CommunicationThread(threading.Thread):
-
     def __init__(self, tests_queue):
         threading.Thread.__init__(self)
         self.daemon = True
@@ -166,12 +166,12 @@ class CommunicationThread(threading.Thread):
         self.server = server
 
     def GetTestsToRun(self, job_id):
-        '''
+        """
         @param job_id:
 
         @return: list(str)
             Each entry is a string in the format: filename|Test.testName
-        '''
+        """
         try:
             ret = self.queue.get(block=False)
             return ret
@@ -195,13 +195,13 @@ class CommunicationThread(threading.Thread):
         return True
 
     def shutdown(self):
-        if hasattr(self.server, 'shutdown'):
+        if hasattr(self.server, "shutdown"):
             self.server.shutdown()
         else:
             self._shutdown = True
 
     def run(self):
-        if hasattr(self.server, 'shutdown'):
+        if hasattr(self.server, "shutdown"):
             self.server.serve_forever()
         else:
             self._shutdown = False
@@ -209,11 +209,10 @@ class CommunicationThread(threading.Thread):
                 self.server.handle_request()
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # Client
-#=======================================================================================================================
+# =======================================================================================================================
 class ClientThread(threading.Thread):
-
     def __init__(self, job_id, port, verbosity, coverage_output_file=None, coverage_include=None):
         threading.Thread.__init__(self)
         self.daemon = True
@@ -252,6 +251,7 @@ class ClientThread(threading.Thread):
                 args.append(self.coverage_include)
 
             import subprocess
+
             if False:
                 proc = subprocess.Popen(args, env=os.environ, shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
@@ -264,4 +264,3 @@ class ClientThread(threading.Thread):
 
         finally:
             self.finished = True
-

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_parallel_client.py

@@ -1,4 +1,5 @@
 from _pydev_bundle.pydev_imports import xmlrpclib, _queue
+
 Queue = _queue.Queue
 import traceback
 import sys
@@ -6,11 +7,10 @@ from _pydev_runfiles.pydev_runfiles_coverage import start_coverage_support_from_
 import threading
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # ParallelNotification
-#=======================================================================================================================
+# =======================================================================================================================
 class ParallelNotification(object):
-
     def __init__(self, method, args, kwargs):
         self.method = method
         self.args = args
@@ -20,25 +20,21 @@ class ParallelNotification(object):
         return self.method, self.args, self.kwargs
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # KillServer
-#=======================================================================================================================
+# =======================================================================================================================
 class KillServer(object):
     pass
 
 
-
-#=======================================================================================================================
+# =======================================================================================================================
 # ServerComm
-#=======================================================================================================================
+# =======================================================================================================================
 class ServerComm(threading.Thread):
-
-
-
     def __init__(self, job_id, server):
         self.notifications_queue = Queue()
         threading.Thread.__init__(self)
-        self.setDaemon(False) #Wait for all the notifications to be passed before exiting!
+        self.setDaemon(False)  # Wait for all the notifications to be passed before exiting!
         assert job_id is not None
         assert port is not None
         self.job_id = job_id
@@ -46,7 +42,6 @@ class ServerComm(threading.Thread):
         self.finished = False
         self.server = server
 
-
     def run(self):
         while True:
             kill_found = False
@@ -60,19 +55,18 @@ class ServerComm(threading.Thread):
 
             try:
                 while True:
-                    command = self.notifications_queue.get(block=False) #No block to create a batch.
+                    command = self.notifications_queue.get(block=False)  # No block to create a batch.
                     if isinstance(command, KillServer):
                         kill_found = True
                     else:
                         assert isinstance(command, ParallelNotification)
                         commands.append(command.to_tuple())
             except:
-                pass #That's OK, we're getting it until it becomes empty so that we notify multiple at once.
-
+                pass  # That's OK, we're getting it until it becomes empty so that we notify multiple at once.
 
             if commands:
                 try:
-                    #Batch notification.
+                    # Batch notification.
                     self.server.lock.acquire()
                     try:
                         self.server.notifyCommands(self.job_id, commands)
@@ -86,44 +80,36 @@ class ServerComm(threading.Thread):
                 return
 
 
-
-#=======================================================================================================================
+# =======================================================================================================================
 # ServerFacade
-#=======================================================================================================================
+# =======================================================================================================================
 class ServerFacade(object):
-
-
     def __init__(self, notifications_queue):
         self.notifications_queue = notifications_queue
 
-
     def notifyTestsCollected(self, *args, **kwargs):
-        pass #This notification won't be passed
-
+        pass  # This notification won't be passed
 
     def notifyTestRunFinished(self, *args, **kwargs):
-        pass #This notification won't be passed
-
+        pass  # This notification won't be passed
 
     def notifyStartTest(self, *args, **kwargs):
-        self.notifications_queue.put_nowait(ParallelNotification('notifyStartTest', args, kwargs))
-
+        self.notifications_queue.put_nowait(ParallelNotification("notifyStartTest", args, kwargs))
 
     def notifyTest(self, *args, **kwargs):
-        self.notifications_queue.put_nowait(ParallelNotification('notifyTest', args, kwargs))
-
+        self.notifications_queue.put_nowait(ParallelNotification("notifyTest", args, kwargs))
 
 
-#=======================================================================================================================
+# =======================================================================================================================
 # run_client
-#=======================================================================================================================
+# =======================================================================================================================
 def run_client(job_id, port, verbosity, coverage_output_file, coverage_include):
     job_id = int(job_id)
 
     from _pydev_bundle import pydev_localhost
-    server = xmlrpclib.Server('http://%s:%s' % (pydev_localhost.get_localhost(), port))
-    server.lock = threading.Lock()
 
+    server = xmlrpclib.Server("http://%s:%s" % (pydev_localhost.get_localhost(), port))
+    server.lock = threading.Lock()
 
     server_comm = ServerComm(job_id, server)
     server_comm.start()
@@ -132,17 +118,18 @@ def run_client(job_id, port, verbosity, coverage_output_file, coverage_include):
         server_facade = ServerFacade(server_comm.notifications_queue)
         from _pydev_runfiles import pydev_runfiles
         from _pydev_runfiles import pydev_runfiles_xml_rpc
+
         pydev_runfiles_xml_rpc.set_server(server_facade)
 
-        #Starts None and when the 1st test is gotten, it's started (because a server may be initiated and terminated
-        #before receiving any test -- which would mean a different process got all the tests to run).
+        # Starts None and when the 1st test is gotten, it's started (because a server may be initiated and terminated
+        # before receiving any test -- which would mean a different process got all the tests to run).
         coverage = None
 
         try:
             tests_to_run = [1]
             while tests_to_run:
-                #Investigate: is it dangerous to use the same xmlrpclib server from different threads?
-                #It seems it should be, as it creates a new connection for each request...
+                # Investigate: is it dangerous to use the same xmlrpclib server from different threads?
+                # It seems it should be, as it creates a new connection for each request...
                 server.lock.acquire()
                 try:
                     tests_to_run = server.GetTestsToRun(job_id)
@@ -153,27 +140,24 @@ def run_client(job_id, port, verbosity, coverage_output_file, coverage_include):
                     break
 
                 if coverage is None:
-                    _coverage_files, coverage = start_coverage_support_from_params(
-                        None, coverage_output_file, 1, coverage_include)
-
+                    _coverage_files, coverage = start_coverage_support_from_params(None, coverage_output_file, 1, coverage_include)
 
                 files_to_tests = {}
                 for test in tests_to_run:
-                    filename_and_test = test.split('|')
+                    filename_and_test = test.split("|")
                     if len(filename_and_test) == 2:
                         files_to_tests.setdefault(filename_and_test[0], []).append(filename_and_test[1])
 
                 configuration = pydev_runfiles.Configuration(
-                    '',
+                    "",
                     verbosity,
                     None,
                     None,
                     None,
                     files_to_tests,
-                    1, #Always single job here
+                    1,  # Always single job here
                     None,
-
-                    #The coverage is handled in this loop.
+                    # The coverage is handled in this loop.
                     coverage_output_file=None,
                     coverage_include=None,
                 )
@@ -185,30 +169,26 @@ def run_client(job_id, port, verbosity, coverage_output_file, coverage_include):
                 coverage.stop()
                 coverage.save()
 
-
     except:
         traceback.print_exc()
     server_comm.notifications_queue.put_nowait(KillServer())
 
 
-
-#=======================================================================================================================
+# =======================================================================================================================
 # main
-#=======================================================================================================================
-if __name__ == '__main__':
-    if len(sys.argv) -1 == 3:
+# =======================================================================================================================
+if __name__ == "__main__":
+    if len(sys.argv) - 1 == 3:
         job_id, port, verbosity = sys.argv[1:]
         coverage_output_file, coverage_include = None, None
 
-    elif len(sys.argv) -1 == 5:
+    elif len(sys.argv) - 1 == 5:
         job_id, port, verbosity, coverage_output_file, coverage_include = sys.argv[1:]
 
     else:
-        raise AssertionError('Could not find out how to handle the parameters: '+sys.argv[1:])
+        raise AssertionError("Could not find out how to handle the parameters: " + sys.argv[1:])
 
     job_id = int(job_id)
     port = int(port)
     verbosity = int(verbosity)
     run_client(job_id, port, verbosity, coverage_output_file, coverage_include)
-
-