debugpy 1.8.0__zip → 1.8.2__zip

debugpy-1.8.0/src/debugpy/_vendored/pydevd/tests_python/my_extensions/pydevd_plugins/extensions/pydevd_plugin_test_events.py

@@ -1,18 +0,0 @@
-from _pydevd_bundle.pydevd_extension_api import DebuggerEventHandler
-import os
-import sys
-
-
-class VerifyEvent(object):
-    def on_debugger_modules_loaded(self, **kwargs):
-        print ("INITIALIZE EVENT RECEIVED")
-        # check that some core modules are loaded before this callback is invoked
-        modules_loaded = all(mod in sys.modules for mod in ('pydevd_file_utils', '_pydevd_bundle.pydevd_constants'))
-        if modules_loaded:
-            print ("TEST SUCEEDED")  # incorrect spelling on purpose
-        else:
-            print ("TEST FAILED")
-
-
-if os.environ.get("VERIFY_EVENT_TEST"):
-    DebuggerEventHandler.register(VerifyEvent)

debugpy-1.8.0/src/debugpy/_vendored/pydevd/tests_python/my_extensions/pydevd_plugins/extensions/pydevd_plugin_test_exttype.py

@@ -1,20 +0,0 @@
-from _pydevd_bundle.pydevd_extension_api import StrPresentationProvider, TypeResolveProvider
-
-
-class RectResolver(TypeResolveProvider):
-    def get_dictionary(self, var):
-        return {'length': var.length, 'width': var.width, 'area': var.length * var.width}
-
-    def resolve(self, var, attribute):
-        return getattr(var, attribute, None) if attribute != 'area' else var.length * var.width
-
-    def can_provide(self, type_object, type_name):
-        return type_name.endswith('Rect')
-
-
-class RectToString(StrPresentationProvider):
-    def get_str(self, val):
-        return "Rectangle[Length: %s, Width: %s , Area: %s]" % (val.length, val.width, val.length * val.width)
-
-    def can_provide(self, type_object, type_name):
-        return type_name.endswith('Rect')

debugpy-1.8.0/src/debugpy/_vendored/pydevd/tests_python/performance_check.py

@@ -1,245 +0,0 @@
-from tests_python import debugger_unittest
-import sys
-import re
-import os
-
-CHECK_BASELINE, CHECK_REGULAR, CHECK_CYTHON, CHECK_FRAME_EVAL = 'baseline', 'regular', 'cython', 'frame_eval'
-
-pytest_plugins = [
-    str('tests_python.debugger_fixtures'),
-]
-
-RUNS = 5
-
-
-class PerformanceWriterThread(debugger_unittest.AbstractWriterThread):
-
-    CHECK = None
-
-    debugger_unittest.AbstractWriterThread.get_environ  # overrides
-
-    def get_environ(self):
-        env = os.environ.copy()
-        if self.CHECK == CHECK_BASELINE:
-            env['PYTHONPATH'] = r'X:\PyDev.Debugger.baseline'
-
-        elif self.CHECK == CHECK_CYTHON:
-            env['PYDEVD_USE_CYTHON'] = 'YES'
-            env['PYDEVD_USE_FRAME_EVAL'] = 'NO'
-
-        elif self.CHECK == CHECK_FRAME_EVAL:
-            env['PYDEVD_USE_CYTHON'] = 'YES'
-            env['PYDEVD_USE_FRAME_EVAL'] = 'YES'
-
-        elif self.CHECK == CHECK_REGULAR:
-            env['PYDEVD_USE_CYTHON'] = 'NO'
-            env['PYDEVD_USE_FRAME_EVAL'] = 'NO'
-
-        else:
-            raise AssertionError("Don't know what to check.")
-        return env
-
-    debugger_unittest.AbstractWriterThread.get_pydevd_file  # overrides
-
-    def get_pydevd_file(self):
-        if self.CHECK == CHECK_BASELINE:
-            return os.path.abspath(os.path.join(r'X:\PyDev.Debugger.baseline', 'pydevd.py'))
-        dirname = os.path.dirname(__file__)
-        dirname = os.path.dirname(dirname)
-        return os.path.abspath(os.path.join(dirname, 'pydevd.py'))
-
-
-class CheckDebuggerPerformance(debugger_unittest.DebuggerRunner):
-
-    def get_command_line(self):
-        return [sys.executable]
-
-    def _get_time_from_result(self, stdout):
-        match = re.search(r'TotalTime>>((\d|\.)+)<<', stdout)
-        time_taken = match.group(1)
-        return float(time_taken)
-
-    def obtain_results(self, benchmark_name, filename):
-
-        class PerformanceCheck(PerformanceWriterThread):
-            TEST_FILE = debugger_unittest._get_debugger_test_file(filename)
-            BENCHMARK_NAME = benchmark_name
-
-        writer_thread_class = PerformanceCheck
-
-        runs = RUNS
-        all_times = []
-        for _ in range(runs):
-            stdout_ref = []
-
-            def store_stdout(stdout, stderr):
-                stdout_ref.append(stdout)
-
-            with self.check_case(writer_thread_class) as writer:
-                writer.additional_output_checks = store_stdout
-                yield writer
-
-            assert len(stdout_ref) == 1
-            all_times.append(self._get_time_from_result(stdout_ref[0]))
-            print('partial for: %s: %.3fs' % (writer_thread_class.BENCHMARK_NAME, all_times[-1]))
-        if len(all_times) > 3:
-            all_times.remove(min(all_times))
-            all_times.remove(max(all_times))
-        time_when_debugged = sum(all_times) / float(len(all_times))
-
-        args = self.get_command_line()
-        args.append(writer_thread_class.TEST_FILE)
-        # regular_time = self._get_time_from_result(self.run_process(args, writer_thread=None))
-        # simple_trace_time = self._get_time_from_result(self.run_process(args+['--regular-trace'], writer_thread=None))
-
-        if 'SPEEDTIN_AUTHORIZATION_KEY' in os.environ:
-
-            SPEEDTIN_AUTHORIZATION_KEY = os.environ['SPEEDTIN_AUTHORIZATION_KEY']
-
-            # sys.path.append(r'X:\speedtin\pyspeedtin')
-            import pyspeedtin  # If the authorization key is there, pyspeedtin must be available
-            import pydevd
-            pydevd_cython_project_id, pydevd_pure_python_project_id = 6, 7
-            if writer_thread_class.CHECK == CHECK_BASELINE:
-                project_ids = (pydevd_cython_project_id, pydevd_pure_python_project_id)
-            elif writer_thread_class.CHECK == CHECK_REGULAR:
-                project_ids = (pydevd_pure_python_project_id,)
-            elif writer_thread_class.CHECK == CHECK_CYTHON:
-                project_ids = (pydevd_cython_project_id,)
-            else:
-                raise AssertionError('Wrong check: %s' % (writer_thread_class.CHECK))
-            for project_id in project_ids:
-                api = pyspeedtin.PySpeedTinApi(authorization_key=SPEEDTIN_AUTHORIZATION_KEY, project_id=project_id)
-
-                benchmark_name = writer_thread_class.BENCHMARK_NAME
-
-                if writer_thread_class.CHECK == CHECK_BASELINE:
-                    version = '0.0.1_baseline'
-                    return  # No longer commit the baseline (it's immutable right now).
-                else:
-                    version = pydevd.__version__,
-
-                commit_id, branch, commit_date = api.git_commit_id_branch_and_date_from_path(pydevd.__file__)
-                api.add_benchmark(benchmark_name)
-                api.add_measurement(
-                    benchmark_name,
-                    value=time_when_debugged,
-                    version=version,
-                    released=False,
-                    branch=branch,
-                    commit_id=commit_id,
-                    commit_date=commit_date,
-                )
-                api.commit()
-
-        self.performance_msg = '%s: %.3fs ' % (writer_thread_class.BENCHMARK_NAME, time_when_debugged)
-
-    def method_calls_with_breakpoint(self):
-        for writer in self.obtain_results('method_calls_with_breakpoint', '_performance_1.py'):
-            writer.write_add_breakpoint(17, 'method')
-            writer.write_make_initial_run()
-            writer.finished_ok = True
-
-        return self.performance_msg
-
-    def method_calls_without_breakpoint(self):
-        for writer in self.obtain_results('method_calls_without_breakpoint', '_performance_1.py'):
-            writer.write_make_initial_run()
-            writer.finished_ok = True
-
-        return self.performance_msg
-
-    def method_calls_with_step_over(self):
-        for writer in self.obtain_results('method_calls_with_step_over', '_performance_1.py'):
-            writer.write_add_breakpoint(26, None)
-
-            writer.write_make_initial_run()
-            hit = writer.wait_for_breakpoint_hit('111')
-
-            writer.write_step_over(hit.thread_id)
-            hit = writer.wait_for_breakpoint_hit('108')
-
-            writer.write_run_thread(hit.thread_id)
-            writer.finished_ok = True
-
-        return self.performance_msg
-
-    def method_calls_with_exception_breakpoint(self):
-        for writer in self.obtain_results('method_calls_with_exception_breakpoint', '_performance_1.py'):
-            writer.write_add_exception_breakpoint('ValueError')
-            writer.write_make_initial_run()
-            writer.finished_ok = True
-
-        return self.performance_msg
-
-    def global_scope_1_with_breakpoint(self):
-        for writer in self.obtain_results('global_scope_1_with_breakpoint', '_performance_2.py'):
-            writer.write_add_breakpoint(writer.get_line_index_with_content('Breakpoint here'), None)
-            writer.write_make_initial_run()
-            writer.finished_ok = True
-
-        return self.performance_msg
-
-    def global_scope_2_with_breakpoint(self):
-        for writer in self.obtain_results('global_scope_2_with_breakpoint', '_performance_3.py'):
-            writer.write_add_breakpoint(17, None)
-            writer.write_make_initial_run()
-            writer.finished_ok = True
-
-        return self.performance_msg
-
-
-if __name__ == '__main__':
-    # Local times gotten (python 3.6)
-    # method_calls_with_breakpoint: 1.150s
-    # method_calls_without_breakpoint: 0.240s
-    # method_calls_with_step_over: 2.680s
-    # method_calls_with_exception_breakpoint: 0.235s
-    # global_scope_1_with_breakpoint: 4.249s
-    # global_scope_2_with_breakpoint: 2.807s
-    # Checking: cython
-    # method_calls_with_breakpoint: 0.526s
-    # method_calls_without_breakpoint: 0.130s
-    # method_calls_with_step_over: 1.133s
-    # method_calls_with_exception_breakpoint: 0.136s
-    # global_scope_1_with_breakpoint: 1.827s
-    # global_scope_2_with_breakpoint: 1.405s
-    # Checking: frame_eval
-    # method_calls_with_breakpoint: 0.133s
-    # method_calls_without_breakpoint: 0.128s
-    # method_calls_with_step_over: 0.130s
-    # method_calls_with_exception_breakpoint: 0.125s
-    # global_scope_1_with_breakpoint: 0.281s
-    # global_scope_2_with_breakpoint: 0.169s
-    # TotalTime for profile: 209.01s
-
-    debugger_unittest.SHOW_WRITES_AND_READS = False
-    debugger_unittest.SHOW_OTHER_DEBUG_INFO = False
-    debugger_unittest.SHOW_STDOUT = False
-
-    import time
-    start_time = time.time()
-
-    tmpdir = None
-
-    msgs = []
-    for check in (
-            # CHECK_BASELINE, -- Checks against the version checked out at X:\PyDev.Debugger.baseline.
-            CHECK_REGULAR,
-            CHECK_CYTHON,
-            CHECK_FRAME_EVAL,
-        ):
-        PerformanceWriterThread.CHECK = check
-        msgs.append('Checking: %s' % (check,))
-        check_debugger_performance = CheckDebuggerPerformance(tmpdir)
-        msgs.append(check_debugger_performance.method_calls_with_breakpoint())
-        msgs.append(check_debugger_performance.method_calls_without_breakpoint())
-        msgs.append(check_debugger_performance.method_calls_with_step_over())
-        msgs.append(check_debugger_performance.method_calls_with_exception_breakpoint())
-        msgs.append(check_debugger_performance.global_scope_1_with_breakpoint())
-        msgs.append(check_debugger_performance.global_scope_2_with_breakpoint())
-
-    for msg in msgs:
-        print(msg)
-
-    print('TotalTime for profile: %.2fs' % (time.time() - start_time,))

debugpy-1.8.0/src/debugpy/_vendored/pydevd/tests_python/regression_check.py

@@ -1,240 +0,0 @@
-# Based on: https://github.com/ESSS/pytest-regressions (License: MIT)
-# Created copy because we need Python 2.6 which is not available on pytest-regressions.
-# Note: only used for testing.
-
-# encoding: UTF-8
-import difflib
-import pytest
-import sys
-from functools import partial
-
-if sys.version_info[0] <= 2:
-    from pathlib2 import Path
-else:
-    from pathlib import Path
-
-FORCE_REGEN = False
-
-
-@pytest.fixture
-def original_datadir(request):
-    # Method from: https://github.com/gabrielcnr/pytest-datadir
-    # License: MIT
-    import os.path
-    return Path(os.path.splitext(request.module.__file__)[0])
-
-
-@pytest.fixture
-def datadir(original_datadir, tmpdir):
-    # Method from: https://github.com/gabrielcnr/pytest-datadir
-    # License: MIT
-    import shutil
-    result = Path(str(tmpdir.join(original_datadir.stem)))
-    if original_datadir.is_dir():
-        shutil.copytree(str(original_datadir), str(result))
-    else:
-        result.mkdir()
-    return result
-
-
-@pytest.fixture
-def data_regression(datadir, original_datadir, request):
-    return DataRegressionFixture(datadir, original_datadir, request)
-
-
-def check_text_files(obtained_fn, expected_fn, fix_callback=lambda x: x, encoding=None):
-    """
-    Compare two files contents. If the files differ, show the diff and write a nice HTML
-    diff file into the data directory.
-    :param Path obtained_fn: path to obtained file during current testing.
-    :param Path expected_fn: path to the expected file, obtained from previous testing.
-    :param str encoding: encoding used to open the files.
-    :param callable fix_callback:
-        A callback to "fix" the contents of the obtained (first) file.
-        This callback receives a list of strings (lines) and must also return a list of lines,
-        changed as needed.
-        The resulting lines will be used to compare with the contents of expected_fn.
-    """
-    __tracebackhide__ = True
-
-    obtained_fn = Path(obtained_fn)
-    expected_fn = Path(expected_fn)
-    obtained_lines = fix_callback(obtained_fn.read_text(encoding=encoding).splitlines())
-    expected_lines = expected_fn.read_text(encoding=encoding).splitlines()
-
-    if obtained_lines != expected_lines:
-        diff_lines = list(difflib.unified_diff(expected_lines, obtained_lines))
-        if len(diff_lines) <= 500:
-            html_fn = obtained_fn.with_suffix(".diff.html")
-            try:
-                differ = difflib.HtmlDiff()
-                html_diff = differ.make_file(
-                    fromlines=expected_lines,
-                    fromdesc=expected_fn,
-                    tolines=obtained_lines,
-                    todesc=obtained_fn,
-                )
-            except Exception as e:
-                html_fn = "(failed to generate html diff: %s)" % e
-            else:
-                html_fn.write_text(html_diff, encoding="UTF-8")
-
-            diff = ["FILES DIFFER:", str(expected_fn), str(obtained_fn)]
-            diff += ["HTML DIFF: %s" % html_fn]
-            diff += diff_lines
-            raise AssertionError("\n".join(diff))
-        else:
-            # difflib has exponential scaling and for thousands of lines it starts to take minutes to render
-            # the HTML diff.
-            msg = [
-                "Files are different, but diff is too big (%s lines)" % (len(diff_lines),),
-                "- obtained: %s" % (obtained_fn,),
-                "- expected: %s" % (expected_fn,),
-            ]
-            raise AssertionError("\n".join(msg))
-
-
-def perform_regression_check(
-    datadir,
-    original_datadir,
-    request,
-    check_fn,
-    dump_fn,
-    extension,
-    basename=None,
-    fullpath=None,
-    obtained_filename=None,
-    dump_aux_fn=lambda filename: [],
-):
-    """
-    First run of this check will generate a expected file. Following attempts will always try to
-    match obtained files with that expected file.
-    :param Path datadir: Fixture embed_data.
-    :param Path original_datadir: Fixture embed_data.
-    :param SubRequest request: Pytest request object.
-    :param callable check_fn: A function that receives as arguments, respectively, absolute path to
-        obtained file and absolute path to expected file. It must assert if contents of file match.
-        Function can safely assume that obtained file is already dumped and only care about
-        comparison.
-    :param callable dump_fn: A function that receive an absolute file path as argument. Implementor
-        must dump file in this path.
-    :param callable dump_aux_fn: A function that receives the same file path as ``dump_fn``, but may
-        dump additional files to help diagnose this regression later (for example dumping image of
-        3d views and plots to compare later). Must return the list of file names written (used to display).
-    :param six.text_type extension: Extension of files compared by this check.
-    :param six.text_type obtained_filename: complete path to use to write the obtained file. By
-        default will prepend `.obtained` before the file extension.
-    ..see: `data_regression.Check` for `basename` and `fullpath` arguments.
-    """
-    import re
-
-    assert not (basename and fullpath), "pass either basename or fullpath, but not both"
-
-    __tracebackhide__ = True
-
-    if basename is None:
-        basename = re.sub(r"[\W]", "_", request.node.name)
-
-    if fullpath:
-        filename = source_filename = Path(fullpath)
-    else:
-        filename = datadir / (basename + extension)
-        source_filename = original_datadir / (basename + extension)
-
-    def make_location_message(banner, filename, aux_files):
-        msg = [banner, "- %s" % (filename,)]
-        if aux_files:
-            msg.append("Auxiliary:")
-            msg += ["- %s" % (x,) for x in aux_files]
-        return "\n".join(msg)
-
-    if not filename.is_file():
-        source_filename.parent.mkdir(parents=True, exist_ok=True)
-        dump_fn(source_filename)
-        aux_created = dump_aux_fn(source_filename)
-
-        msg = make_location_message(
-            "File not found in data directory, created:", source_filename, aux_created
-        )
-        pytest.fail(msg)
-    else:
-        if obtained_filename is None:
-            if fullpath:
-                obtained_filename = (datadir / basename).with_suffix(
-                    ".obtained" + extension
-                )
-            else:
-                obtained_filename = filename.with_suffix(".obtained" + extension)
-
-        dump_fn(obtained_filename)
-
-        try:
-            check_fn(obtained_filename, filename)
-        except AssertionError:
-            if FORCE_REGEN:
-                dump_fn(source_filename)
-                aux_created = dump_aux_fn(source_filename)
-                msg = make_location_message(
-                    "Files differ and FORCE_REGEN set, regenerating file at:",
-                    source_filename,
-                    aux_created,
-                )
-                pytest.fail(msg)
-            else:
-                dump_aux_fn(obtained_filename)
-                raise
-
-
-class DataRegressionFixture(object):
-    """
-    Implementation of `data_regression` fixture.
-    """
-
-    def __init__(self, datadir, original_datadir, request):
-        """
-        :type datadir: Path
-        :type original_datadir: Path
-        :type request: FixtureRequest
-        """
-        self.request = request
-        self.datadir = datadir
-        self.original_datadir = original_datadir
-
-    def check(self, data_dict, basename=None, fullpath=None):
-        """
-        Checks the given dict against a previously recorded version, or generate a new file.
-        :param dict data_dict: any yaml serializable dict.
-        :param str basename: basename of the file to test/record. If not given the name
-            of the test is used.
-            Use either `basename` or `fullpath`.
-        :param str fullpath: complete path to use as a reference file. This option
-            will ignore ``datadir`` fixture when reading *expected* files but will still use it to
-            write *obtained* files. Useful if a reference file is located in the session data dir for example.
-        ``basename`` and ``fullpath`` are exclusive.
-        """
-        __tracebackhide__ = True
-
-        def dump(filename):
-            """Dump dict contents to the given filename"""
-            import json
-
-            s = json.dumps(data_dict, sort_keys=True, indent=4)
-            if isinstance(s, bytes):
-                s = s.decode('utf-8')
-
-            s = u'\n'.join([line.rstrip() for line in s.splitlines()])
-            s = s.encode('utf-8')
-
-            with filename.open("wb") as f:
-                f.write(s)
-
-        perform_regression_check(
-            datadir=self.datadir,
-            original_datadir=self.original_datadir,
-            request=self.request,
-            check_fn=partial(check_text_files, encoding="UTF-8"),
-            dump_fn=dump,
-            extension=".json",
-            basename=basename,
-            fullpath=fullpath,
-        )

debugpy-1.8.0/src/debugpy/_vendored/pydevd/tests_python/resource_path_translation/other.py

@@ -1,6 +0,0 @@
-
-
-def call_me_back1(callback):
-    a = 'other'
-    callback()
-    return a