debugpy 1.8.5__zip → 1.8.6__zip

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__init__.py

@@ -129,9 +129,7 @@ def get_code(source, *, filename="<string>", function=False):
     source = textwrap.dedent(source).strip()
     code = compile(source, filename, "exec")
     if function:
-        sub_code = [
-            const for const in code.co_consts if isinstance(const, types.CodeType)
-        ]
+        sub_code = [const for const in code.co_consts if isinstance(const, types.CodeType)]
         if len(sub_code) != 1:
             raise ValueError("unable to find function code")
         code = sub_code[0]
@@ -149,6 +147,4 @@ class TestCase(unittest.TestCase):
 
         for block1, block2 in zip(code, expected_blocks):
             block_index = code.get_block_index(block1)
-            self.assertListEqual(
-                list(block1), block2, "Block #%s is different" % block_index
-            )
+            self.assertListEqual(list(block1), block2, "Block #%s is different" % block_index)

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_bytecode.py

@@ -1,8 +1,8 @@
-
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
-pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
+
+pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason="Requires CPython >= 3.6")
 #!/usr/bin/env python3
 import sys
 import textwrap
@@ -90,9 +90,7 @@ class BytecodeTests(TestCase):
             "freevars",
             "argnames",
         ):
-            self.assertEqual(
-                getattr(code, name, None), getattr(sliced_code, name, None)
-            )
+            self.assertEqual(getattr(code, name, None), getattr(sliced_code, name, None))
 
     def test_copy(self):
         code = Bytecode()

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_cfg.py

@@ -1,8 +1,8 @@
-
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
-pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
+
+pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason="Requires CPython >= 3.6")
 #!/usr/bin/env python3
 import io
 import sys
@@ -21,24 +21,16 @@ from _pydevd_frame_eval.vendored.bytecode.concrete import OFFSET_AS_INSTRUCTION
 from _pydevd_frame_eval.vendored.bytecode.tests import disassemble as _disassemble, TestCase
 
 
-def disassemble(
-    source, *, filename="<string>", function=False, remove_last_return_none=False
-):
+def disassemble(source, *, filename="<string>", function=False, remove_last_return_none=False):
     code = _disassemble(source, filename=filename, function=function)
     blocks = ControlFlowGraph.from_bytecode(code)
     if remove_last_return_none:
         # drop LOAD_CONST+RETURN_VALUE to only keep 2 instructions,
         # to make unit tests shorter
         block = blocks[-1]
-        test = (
-            block[-2].name == "LOAD_CONST"
-            and block[-2].arg is None
-            and block[-1].name == "RETURN_VALUE"
-        )
+        test = block[-2].name == "LOAD_CONST" and block[-2].arg is None and block[-1].name == "RETURN_VALUE"
         if not test:
-            raise ValueError(
-                "unable to find implicit RETURN_VALUE <None>: %s" % block[-2:]
-            )
+            raise ValueError("unable to find implicit RETURN_VALUE <None>: %s" % block[-2:])
         del block[-2:]
     return blocks
 
@@ -458,9 +450,7 @@ class BytecodeBlocksFunctionalTests(TestCase):
 
     def sample_code(self):
         code = disassemble("x = 1", remove_last_return_none=True)
-        self.assertBlocksEqual(
-            code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)]
-        )
+        self.assertBlocksEqual(code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)])
         return code
 
     def test_split_block(self):
@@ -522,9 +512,7 @@ class BytecodeBlocksFunctionalTests(TestCase):
         # FIXME: is it really useful to support that?
         block = code.split_block(code[0], 0)
         self.assertIs(block, code[0])
-        self.assertBlocksEqual(
-            code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)]
-        )
+        self.assertBlocksEqual(code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)])
 
     def test_split_block_error(self):
         code = self.sample_code()
@@ -555,9 +543,7 @@ class BytecodeBlocksFunctionalTests(TestCase):
                 Instr("POP_JUMP_IF_FALSE", block2, lineno=4),
             ]
         )
-        block1.extend(
-            [Instr("LOAD_FAST", "arg", lineno=5), Instr("STORE_FAST", "x", lineno=5)]
-        )
+        block1.extend([Instr("LOAD_FAST", "arg", lineno=5), Instr("STORE_FAST", "x", lineno=5)])
         block2.extend(
             [
                 Instr("LOAD_CONST", 3, lineno=6),
@@ -569,13 +555,9 @@ class BytecodeBlocksFunctionalTests(TestCase):
 
         if OFFSET_AS_INSTRUCTION:
             # The argument of the jump is divided by 2
-            expected = (
-                b"|\x05" b"r\x04" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00"
-            )
+            expected = b"|\x05" b"r\x04" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00"
         else:
-            expected = (
-                b"|\x05" b"r\x08" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00"
-            )
+            expected = b"|\x05" b"r\x08" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00"
 
         code = bytecode.to_code()
         self.assertEqual(code.co_consts, (None, 3))
@@ -589,9 +571,7 @@ class BytecodeBlocksFunctionalTests(TestCase):
         self.assertEqual(code.co_flags, 0x43)
         self.assertEqual(code.co_code, expected)
         self.assertEqual(code.co_names, ())
-        self.assertEqual(
-            code.co_varnames, ("arg", "arg2", "arg3", "kwonly", "kwonly2", "x")
-        )
+        self.assertEqual(code.co_varnames, ("arg", "arg2", "arg3", "kwonly", "kwonly2", "x"))
         self.assertEqual(code.co_filename, "hello.py")
         self.assertEqual(code.co_name, "func")
         self.assertEqual(code.co_firstlineno, 3)

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_code.py

@@ -1,8 +1,8 @@
-
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
-pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
+
+pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason="Requires CPython >= 3.6")
 import unittest
 
 from _pydevd_frame_eval.vendored.bytecode import ConcreteBytecode, Bytecode, ControlFlowGraph

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_concrete.py

@@ -1,8 +1,8 @@
-
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
-pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
+
+pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason="Requires CPython >= 3.6")
 #!/usr/bin/env python3
 import opcode
 import sys
@@ -167,9 +167,7 @@ class ConcreteInstrTests(TestCase):
         self.assertEqual(jump_abs.get_jump_target(100), 3)
 
         jump_forward = ConcreteInstr("JUMP_FORWARD", 5)
-        self.assertEqual(
-            jump_forward.get_jump_target(10), 16 if OFFSET_AS_INSTRUCTION else 17
-        )
+        self.assertEqual(jump_forward.get_jump_target(10), 16 if OFFSET_AS_INSTRUCTION else 17)
 
 
 class ConcreteBytecodeTests(TestCase):
@@ -241,7 +239,6 @@ class ConcreteBytecodeTests(TestCase):
             ConcreteBytecode([Label()])
 
     def test_to_code_lnotab(self):
-
         # We use an actual function for the simple case to
         # ensure we get lnotab right
         def f():
@@ -454,9 +451,7 @@ class ConcreteBytecodeTests(TestCase):
         concrete = ConcreteBytecode()
         concrete.cellvars = ["__class__"]
         concrete.freevars = ["__class__"]
-        concrete.extend(
-            [ConcreteInstr("LOAD_CLASSDEREF", 1), ConcreteInstr("STORE_DEREF", 1)]
-        )
+        concrete.extend([ConcreteInstr("LOAD_CLASSDEREF", 1), ConcreteInstr("STORE_DEREF", 1)])
 
         bytecode = concrete.to_bytecode()
         self.assertEqual(bytecode.freevars, ["__class__"])
@@ -582,11 +577,7 @@ class ConcreteFromCodeTests(TestCase):
         # Create a code object from arbitrary bytecode
         co_code = b"\x90\x12\x904\x90\xabd\xcd"
         code = get_code("x=1")
-        args = (
-            (code.co_argcount,)
-            if sys.version_info < (3, 8)
-            else (code.co_argcount, code.co_posonlyargcount)
-        )
+        args = (code.co_argcount,) if sys.version_info < (3, 8) else (code.co_argcount, code.co_posonlyargcount)
         args += (
             code.co_kwonlyargcount,
             code.co_nlocals,
@@ -608,9 +599,7 @@ class ConcreteFromCodeTests(TestCase):
 
         # without EXTENDED_ARG opcode
         bytecode = ConcreteBytecode.from_code(code)
-        self.assertListEqual(
-            list(bytecode), [ConcreteInstr("LOAD_CONST", 0x1234ABCD, lineno=1)]
-        )
+        self.assertListEqual(list(bytecode), [ConcreteInstr("LOAD_CONST", 0x1234ABCD, lineno=1)])
 
         # with EXTENDED_ARG opcode
         bytecode = ConcreteBytecode.from_code(code, extended_arg=True)
@@ -655,10 +644,7 @@ class ConcreteFromCodeTests(TestCase):
                 ConcreteInstr("LOAD_NAME", 0, lineno=1),
                 ConcreteInstr("BUILD_TUPLE", 4, lineno=1),
             ]
-        elif (
-            sys.version_info >= (3, 7)
-            and concrete.flags & CompilerFlags.FUTURE_ANNOTATIONS
-        ):
+        elif sys.version_info >= (3, 7) and concrete.flags & CompilerFlags.FUTURE_ANNOTATIONS:
             func_code = concrete.consts[2]
             names = ["foo"]
             consts = ["int", ("x", "y"), func_code, "foo", None]
@@ -726,9 +712,7 @@ class ConcreteFromCodeTests(TestCase):
             return q, r, s, t
 
         cpython_stacksize = test.__code__.co_stacksize
-        test.__code__ = ConcreteBytecode.from_code(
-            test.__code__, extended_arg=True
-        ).to_code()
+        test.__code__ = ConcreteBytecode.from_code(test.__code__, extended_arg=True).to_code()
         self.assertEqual(test.__code__.co_stacksize, cpython_stacksize)
         self.assertEqual(test(), (1, 2, [3, 4, 5], 6))
 
@@ -997,9 +981,7 @@ class ConcreteFromCodeTests(TestCase):
 
             return var
 
-        test.__code__ = ConcreteBytecode.from_code(
-            test.__code__, extended_arg=True
-        ).to_code()
+        test.__code__ = ConcreteBytecode.from_code(test.__code__, extended_arg=True).to_code()
         self.assertEqual(test.__code__.co_stacksize, 1)
         self.assertEqual(test(), 259)
 
@@ -1130,9 +1112,7 @@ class BytecodeToConcreteTests(TestCase):
         concrete = bytecode.to_concrete_bytecode()
         expected = [
             ConcreteInstr("LOAD_NAME", 0, lineno=1),
-            ConcreteInstr(
-                "POP_JUMP_IF_FALSE", 7 if OFFSET_AS_INSTRUCTION else 14, lineno=1
-            ),
+            ConcreteInstr("POP_JUMP_IF_FALSE", 7 if OFFSET_AS_INSTRUCTION else 14, lineno=1),
             ConcreteInstr("LOAD_CONST", 0, lineno=2),
             ConcreteInstr("STORE_NAME", 1, lineno=2),
             ConcreteInstr("JUMP_FORWARD", 2 if OFFSET_AS_INSTRUCTION else 4, lineno=2),
@@ -1205,9 +1185,7 @@ class BytecodeToConcreteTests(TestCase):
         self.assertEqual(func(18), -1)
 
         # Ensure that we properly round trip in such cases
-        self.assertEqual(
-            ConcreteBytecode.from_code(code).to_code().co_code, code.co_code
-        )
+        self.assertEqual(ConcreteBytecode.from_code(code).to_code().co_code, code.co_code)
 
     def test_setlineno(self):
         # x = 7
@@ -1259,7 +1237,7 @@ class BytecodeToConcreteTests(TestCase):
 
         # (invalid) code using jumps > 0xffff to test extended arg
         label = Label()
-        nb_nop = 2 ** 16
+        nb_nop = 2**16
         code = Bytecode(
             [
                 Instr("JUMP_ABSOLUTE", label),
@@ -1304,9 +1282,7 @@ class BytecodeToConcreteTests(TestCase):
         code = code.to_concrete_bytecode()
         expected = [
             ConcreteInstr("LOAD_NAME", 0, lineno=1),
-            ConcreteInstr(
-                "POP_JUMP_IF_FALSE", 5 if OFFSET_AS_INSTRUCTION else 10, lineno=1
-            ),
+            ConcreteInstr("POP_JUMP_IF_FALSE", 5 if OFFSET_AS_INSTRUCTION else 10, lineno=1),
             ConcreteInstr("LOAD_CONST", 0, lineno=2),
             ConcreteInstr("STORE_NAME", 1, lineno=2),
             ConcreteInstr("JUMP_FORWARD", 2 if OFFSET_AS_INSTRUCTION else 4, lineno=2),
@@ -1448,10 +1424,7 @@ class BytecodeToConcreteTests(TestCase):
         labels = [Label() for x in range(0, 3 * N)]
 
         code = Bytecode()
-        code.extend(
-            Instr("JUMP_FORWARD", labels[len(labels) - x - 1])
-            for x in range(0, len(labels))
-        )
+        code.extend(Instr("JUMP_FORWARD", labels[len(labels) - x - 1]) for x in range(0, len(labels)))
         end_of_jumps = len(code)
         code.extend(Instr(nop) for x in range(0, N))
 

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_flags.py

@@ -1,8 +1,8 @@
-
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
-pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
+
+pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason="Requires CPython >= 3.6")
 #!/usr/bin/env python3
 import unittest
 from _pydevd_frame_eval.vendored.bytecode import (
@@ -21,7 +21,6 @@ class FlagsTests(unittest.TestCase):
             infer_flags(1)
 
     def test_flag_inference(self):
-
         # Check no loss of non-infered flags
         code = ControlFlowGraph()
         code.flags |= (
@@ -122,7 +121,6 @@ class FlagsTests(unittest.TestCase):
         # Test inference in the presence of pre-existing flags
 
         for is_async in (None, True):
-
             # Infer generator
             code = ConcreteBytecode()
             code.append(ConcreteInstr("YIELD_VALUE"))

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_instr.py

@@ -1,8 +1,8 @@
-
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
-pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
+
+pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason="Requires CPython >= 3.6")
 #!/usr/bin/env python3
 import opcode
 import unittest
@@ -78,7 +78,6 @@ class InstrTests(TestCase):
             Instr("xxx")
 
     def test_repr(self):
-
         # No arg
         r = repr(Instr("NOP", lineno=10))
         self.assertIn("NOP", r)
@@ -253,9 +252,7 @@ class InstrTests(TestCase):
         self.assertNotEqual(Instr("LOAD_CONST", 0), Instr("LOAD_CONST", 0.0))
 
         # float: -0.0 == +0.0
-        self.assertNotEqual(
-            Instr("LOAD_CONST", neg_zero), Instr("LOAD_CONST", pos_zero)
-        )
+        self.assertNotEqual(Instr("LOAD_CONST", neg_zero), Instr("LOAD_CONST", pos_zero))
 
         # complex
         self.assertNotEqual(
@@ -273,14 +270,10 @@ class InstrTests(TestCase):
         nested_tuple1 = (nested_tuple1,)
         nested_tuple2 = (0.0,)
         nested_tuple2 = (nested_tuple2,)
-        self.assertNotEqual(
-            Instr("LOAD_CONST", nested_tuple1), Instr("LOAD_CONST", nested_tuple2)
-        )
+        self.assertNotEqual(Instr("LOAD_CONST", nested_tuple1), Instr("LOAD_CONST", nested_tuple2))
 
         # frozenset
-        self.assertNotEqual(
-            Instr("LOAD_CONST", frozenset({0})), Instr("LOAD_CONST", frozenset({0.0}))
-        )
+        self.assertNotEqual(Instr("LOAD_CONST", frozenset({0})), Instr("LOAD_CONST", frozenset({0.0})))
 
     def test_stack_effects(self):
         # Verify all opcodes are handled and that "jump=None" really returns
@@ -322,7 +315,7 @@ class InstrTests(TestCase):
         # (As a result we can calculate stack_effect for
         #  any LOAD_CONST instructions, even for large integers)
 
-        for arg in 2 ** 31, 2 ** 32, 2 ** 63, 2 ** 64, -1:
+        for arg in 2**31, 2**32, 2**63, 2**64, -1:
             self.assertEqual(Instr("LOAD_CONST", arg).stack_effect(), 1)
 
     def test_code_object_containing_mutable_data(self):
@@ -340,11 +333,7 @@ class InstrTests(TestCase):
         mutable_datum = [4, 2]
 
         for each in f_code:
-            if (
-                isinstance(each, Instr)
-                and each.name == "LOAD_CONST"
-                and isinstance(each.arg, CodeType)
-            ):
+            if isinstance(each, Instr) and each.name == "LOAD_CONST" and isinstance(each.arg, CodeType):
                 instr_load_code = each
                 break
 

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_misc.py

@@ -1,8 +1,8 @@
-
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
-pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
+
+pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason="Requires CPython >= 3.6")
 #!/usr/bin/env python3
 import contextlib
 import io
@@ -62,11 +62,7 @@ label_instr13:
     LOAD_CONST 3
     RETURN_VALUE
 
-        """[
-            1:
-        ].rstrip(
-            " "
-        )
+        """[1:].rstrip(" ")
         self.check_dump_bytecode(code, expected)
 
         # with line numbers
@@ -90,11 +86,7 @@ label_instr13:
     L.  6  14: LOAD_CONST 3
            15: RETURN_VALUE
 
-        """[
-            1:
-        ].rstrip(
-            " "
-        )
+        """[1:].rstrip(" ")
         self.check_dump_bytecode(code, expected, lineno=True)
 
     def test_bytecode_broken_label(self):
@@ -225,9 +217,7 @@ label_instr13:
  22    RETURN_VALUE
  24    LOAD_CONST 3
  26    RETURN_VALUE
-""".lstrip(
-            "\n"
-        )
+""".lstrip("\n")
         self.check_dump_bytecode(code, expected)
 
         # with line numbers
@@ -246,9 +236,7 @@ L.  5  20: LOAD_CONST 2
        22: RETURN_VALUE
 L.  6  24: LOAD_CONST 3
        26: RETURN_VALUE
-""".lstrip(
-            "\n"
-        )
+""".lstrip("\n")
         self.check_dump_bytecode(code, expected, lineno=True)
 
     def test_type_validation(self):

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_peephole_opt.py

@@ -1,8 +1,8 @@
-
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
-pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
+
+pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason="Requires CPython >= 3.6")
 import sys
 import unittest
 from _pydevd_frame_eval.vendored.bytecode import Label, Instr, Compare, Bytecode, ControlFlowGraph
@@ -12,7 +12,6 @@ from unittest import mock
 
 
 class Tests(TestCase):
-
     maxDiff = 80 * 100
 
     def optimize_blocks(self, code):
@@ -51,9 +50,7 @@ class Tests(TestCase):
 
     def test_unary_op(self):
         def check_unary_op(op, value, result):
-            code = Bytecode(
-                [Instr("LOAD_CONST", value), Instr(op), Instr("STORE_NAME", "x")]
-            )
+            code = Bytecode([Instr("LOAD_CONST", value), Instr(op), Instr("STORE_NAME", "x")])
             self.check(code, Instr("LOAD_CONST", result), Instr("STORE_NAME", "x"))
 
         check_unary_op("UNARY_POSITIVE", 2, 2)
@@ -520,9 +517,7 @@ class Tests(TestCase):
             ]
         )
         code = ControlFlowGraph.from_bytecode(code)
-        self.check(
-            code, Instr("LOAD_CONST", 4, lineno=2), Instr("RETURN_VALUE", lineno=2)
-        )
+        self.check(code, Instr("LOAD_CONST", 4, lineno=2), Instr("RETURN_VALUE", lineno=2))
 
         # return+return + return+return: remove second and fourth return
         #
@@ -544,9 +539,7 @@ class Tests(TestCase):
             ]
         )
         code = ControlFlowGraph.from_bytecode(code)
-        self.check(
-            code, Instr("LOAD_CONST", 4, lineno=2), Instr("RETURN_VALUE", lineno=2)
-        )
+        self.check(code, Instr("LOAD_CONST", 4, lineno=2), Instr("RETURN_VALUE", lineno=2))
 
         # return + JUMP_ABSOLUTE: remove JUMP_ABSOLUTE
         # while 1:
@@ -594,9 +587,7 @@ class Tests(TestCase):
             )
             code = ControlFlowGraph.from_bytecode(code)
 
-            self.check(
-                code, Instr("LOAD_CONST", 7, lineno=3), Instr("RETURN_VALUE", lineno=3)
-            )
+            self.check(code, Instr("LOAD_CONST", 7, lineno=3), Instr("RETURN_VALUE", lineno=3))
 
     def test_not_jump_if_false(self):
         # Replace UNARY_NOT+POP_JUMP_IF_FALSE with POP_JUMP_IF_TRUE
@@ -905,9 +896,7 @@ class Tests(TestCase):
             )
 
     def test_nop(self):
-        code = Bytecode(
-            [Instr("LOAD_NAME", "x"), Instr("NOP"), Instr("STORE_NAME", "test")]
-        )
+        code = Bytecode([Instr("LOAD_NAME", "x"), Instr("NOP"), Instr("STORE_NAME", "test")])
 
         self.check(code, Instr("LOAD_NAME", "x"), Instr("STORE_NAME", "test"))
 

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/util_annotation.py

@@ -8,9 +8,7 @@ def get_code(source, *, filename="<string>", function=False):
     source = textwrap.dedent(source).strip()
     code = compile(source, filename, "exec")
     if function:
-        sub_code = [
-            const for const in code.co_consts if isinstance(const, types.CodeType)
-        ]
+        sub_code = [const for const in code.co_consts if isinstance(const, types.CodeType)]
         if len(sub_code) != 1:
             raise ValueError("unable to find function code")
         code = sub_code[0]

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/pydevd_fix_code.py

@@ -1,27 +1,21 @@
 def _fix_contents(filename, contents):
     import re
 
-    contents = re.sub(
-        r"from bytecode", r'from _pydevd_frame_eval.vendored.bytecode', contents, flags=re.MULTILINE
-    )
+    contents = re.sub(r"from bytecode", r"from _pydevd_frame_eval.vendored.bytecode", contents, flags=re.MULTILINE)
 
-    contents = re.sub(
-        r"import bytecode", r'from _pydevd_frame_eval.vendored import bytecode', contents, flags=re.MULTILINE
-    )
+    contents = re.sub(r"import bytecode", r"from _pydevd_frame_eval.vendored import bytecode", contents, flags=re.MULTILINE)
 
     # This test will import the wrong setup (we're not interested in it).
-    contents = re.sub(
-        r"def test_version\(self\):", r'def skip_test_version(self):', contents, flags=re.MULTILINE
-    )
+    contents = re.sub(r"def test_version\(self\):", r"def skip_test_version(self):", contents, flags=re.MULTILINE)
 
-    if filename.startswith('test_'):
-        if 'pytestmark' not in contents:
-            pytest_mark = '''
+    if filename.startswith("test_"):
+        if "pytestmark" not in contents:
+            pytest_mark = """
 import pytest
 from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON
 from tests_python.debug_constants import TEST_CYTHON
 pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6')
-'''
+"""
             contents = pytest_mark + contents
     return contents
 
@@ -33,18 +27,19 @@ def main():
     for root, dirs, files in os.walk(os.path.dirname(__file__)):
         path = root.split(os.sep)
         for filename in files:
-            if filename.endswith('.py') and filename != 'pydevd_fix_code.py':
-                with open(os.path.join(root, filename), 'r') as stream:
+            if filename.endswith(".py") and filename != "pydevd_fix_code.py":
+                with open(os.path.join(root, filename), "r") as stream:
                     contents = stream.read()
 
                 new_contents = _fix_contents(filename, contents)
                 if contents != new_contents:
-                    print('fixed ', os.path.join(root, filename))
-                    with open(os.path.join(root, filename), 'w') as stream:
+                    print("fixed ", os.path.join(root, filename))
+                    with open(os.path.join(root, filename), "w") as stream:
                         stream.write(new_contents)
 
+
 #             print(len(path) * '---', filename)
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    main()