debugpy 1.8.5__zip → 1.8.6__zip

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

@@ -18,7 +18,7 @@ dummy_tracing_holder = DummyTracingHolder()
 
 
 def update_globals_dict(globals_dict):
-    new_globals = {'_pydev_stop_at_break': _pydev_stop_at_break}
+    new_globals = {"_pydev_stop_at_break": _pydev_stop_at_break}
     globals_dict.update(new_globals)
 
 
@@ -50,9 +50,9 @@ def _pydev_stop_at_break(line):
             return
 
         pydev_log.debug("Setting f_trace due to frame eval mode in file: %s on line %s", frame.f_code.co_filename, line)
-        additional_info.trace_suspend_type = 'frame_eval'
+        additional_info.trace_suspend_type = "frame_eval"
 
-        pydevd_frame_eval_cython_wrapper = sys.modules['_pydevd_frame_eval.pydevd_frame_eval_cython_wrapper']
+        pydevd_frame_eval_cython_wrapper = sys.modules["_pydevd_frame_eval.pydevd_frame_eval_cython_wrapper"]
         thread_info = pydevd_frame_eval_cython_wrapper.get_thread_info_py()
         if thread_info.thread_trace_func is not None:
             frame.f_trace = thread_info.thread_trace_func
@@ -63,7 +63,7 @@ def _pydev_stop_at_break(line):
 
 
 def _pydev_needs_stop_at_break(line):
-    '''
+    """
     We separate the functionality into 2 functions so that we can generate a bytecode which
     generates a spurious line change so that we can do:
 
@@ -72,7 +72,7 @@ def _pydev_needs_stop_at_break(line):
         _pydev_stop_at_break()
         # then, proceed to go to the current line
         # (which will then trigger a line event).
-    '''
+    """
     t = threading.current_thread()
     try:
         additional_info = t.additional_info
@@ -119,4 +119,3 @@ def _pydev_needs_stop_at_break(line):
         additional_info.is_tracing -= 1
 
     return False
-

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

@@ -14,43 +14,42 @@ DEBUG = False
 
 
 class DebugHelper(object):
-
     def __init__(self):
-        self._debug_dir = os.path.join(os.path.dirname(__file__), 'debug_info')
+        self._debug_dir = os.path.join(os.path.dirname(__file__), "debug_info")
         try:
             os.makedirs(self._debug_dir)
         except:
             pass
         self._next = partial(next, itertools.count(0))
 
-    def _get_filename(self, op_number=None, prefix=''):
+    def _get_filename(self, op_number=None, prefix=""):
         if op_number is None:
             op_number = self._next()
-            name = '%03d_before.txt' % op_number
+            name = "%03d_before.txt" % op_number
         else:
-            name = '%03d_change.txt' % op_number
+            name = "%03d_change.txt" % op_number
 
         filename = os.path.join(self._debug_dir, prefix + name)
         return filename, op_number
 
-    def write_bytecode(self, b, op_number=None, prefix=''):
+    def write_bytecode(self, b, op_number=None, prefix=""):
         filename, op_number = self._get_filename(op_number, prefix)
-        with open(filename, 'w') as stream:
+        with open(filename, "w") as stream:
             bytecode.dump_bytecode(b, stream=stream, lineno=True)
         return op_number
 
-    def write_dis(self, code_to_modify, op_number=None, prefix=''):
+    def write_dis(self, code_to_modify, op_number=None, prefix=""):
         filename, op_number = self._get_filename(op_number, prefix)
-        with open(filename, 'w') as stream:
-            stream.write('-------- ')
-            stream.write('-------- ')
-            stream.write('id(code_to_modify): %s' % id(code_to_modify))
-            stream.write('\n\n')
+        with open(filename, "w") as stream:
+            stream.write("-------- ")
+            stream.write("-------- ")
+            stream.write("id(code_to_modify): %s" % id(code_to_modify))
+            stream.write("\n\n")
             dis.dis(code_to_modify, file=stream)
         return op_number
 
 
-_CodeLineInfo = namedtuple('_CodeLineInfo', 'line_to_offset, first_line, last_line')
+_CodeLineInfo = namedtuple("_CodeLineInfo", "line_to_offset, first_line, last_line")
 
 
 # Note: this method has a version in cython too (that one is usually used, this is just for tests).
@@ -72,19 +71,15 @@ if DEBUG:
     debug_helper = DebugHelper()
 
 
-def get_instructions_to_add(
-        stop_at_line,
-        _pydev_stop_at_break=_pydev_stop_at_break,
-        _pydev_needs_stop_at_break=_pydev_needs_stop_at_break
-    ):
-    '''
+def get_instructions_to_add(stop_at_line, _pydev_stop_at_break=_pydev_stop_at_break, _pydev_needs_stop_at_break=_pydev_needs_stop_at_break):
+    """
     This is the bytecode for something as:
 
         if _pydev_needs_stop_at_break():
             _pydev_stop_at_break()
 
     but with some special handling for lines.
-    '''
+    """
     # Good reference to how things work regarding line numbers and jumps:
     # https://github.com/python/cpython/blob/3.6/Objects/lnotab_notes.txt
 
@@ -100,7 +95,6 @@ def get_instructions_to_add(
         Instr("LOAD_CONST", stop_at_line, lineno=stop_at_line),
         Instr("CALL_FUNCTION", 1, lineno=stop_at_line),
         Instr("POP_JUMP_IF_FALSE", label, lineno=stop_at_line),
-
         #     -- _pydev_stop_at_break()
         #
         # Note that this has line numbers -1 so that when the NOP just below
@@ -109,7 +103,6 @@ def get_instructions_to_add(
         Instr("LOAD_CONST", stop_at_line, lineno=spurious_line),
         Instr("CALL_FUNCTION", 1, lineno=spurious_line),
         Instr("POP_TOP", lineno=spurious_line),
-
         # Reason for the NOP: Python will give us a 'line' trace event whenever we forward jump to
         # the first instruction of a line, so, in the case where we haven't added a programmatic
         # breakpoint (either because we didn't hit a breakpoint anymore or because it was already
@@ -122,7 +115,6 @@ def get_instructions_to_add(
 
 
 class _Node(object):
-
     def __init__(self, data):
         self.prev = None
         self.next = None
@@ -158,11 +150,11 @@ class _Node(object):
 
 
 class _HelperBytecodeList(object):
-    '''
+    """
     A helper double-linked list to make the manipulation a bit easier (so that we don't need
     to keep track of indices that change) and performant (because adding multiple items to
     the middle of a regular list isn't ideal).
-    '''
+    """
 
     def __init__(self, lst=None):
         self._head = None
@@ -206,16 +198,24 @@ class _HelperBytecodeList(object):
 
 
 _PREDICT_TABLE = {
-    'LIST_APPEND': ('JUMP_ABSOLUTE',),
-    'SET_ADD': ('JUMP_ABSOLUTE',),
-    'GET_ANEXT': ('LOAD_CONST',),
-    'GET_AWAITABLE': ('LOAD_CONST',),
-    'DICT_MERGE': ('CALL_FUNCTION_EX',),
-    'MAP_ADD': ('JUMP_ABSOLUTE',),
-    'COMPARE_OP': ('POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE',),
-    'IS_OP': ('POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE',),
-    'CONTAINS_OP': ('POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE',),
-
+    "LIST_APPEND": ("JUMP_ABSOLUTE",),
+    "SET_ADD": ("JUMP_ABSOLUTE",),
+    "GET_ANEXT": ("LOAD_CONST",),
+    "GET_AWAITABLE": ("LOAD_CONST",),
+    "DICT_MERGE": ("CALL_FUNCTION_EX",),
+    "MAP_ADD": ("JUMP_ABSOLUTE",),
+    "COMPARE_OP": (
+        "POP_JUMP_IF_FALSE",
+        "POP_JUMP_IF_TRUE",
+    ),
+    "IS_OP": (
+        "POP_JUMP_IF_FALSE",
+        "POP_JUMP_IF_TRUE",
+    ),
+    "CONTAINS_OP": (
+        "POP_JUMP_IF_FALSE",
+        "POP_JUMP_IF_TRUE",
+    ),
     # Note: there are some others with PREDICT on ceval, but they have more logic
     # and it needs more experimentation to know how it behaves in the static generated
     # code (and it's only an issue for us if there's actually a line change between
@@ -236,12 +236,12 @@ FIX_PREDICT = sys.version_info[:2] >= (3, 10)
 
 
 def insert_pydevd_breaks(
-        code_to_modify,
-        breakpoint_lines,
-        code_line_info=None,
-        _pydev_stop_at_break=_pydev_stop_at_break,
-        _pydev_needs_stop_at_break=_pydev_needs_stop_at_break,
-    ):
+    code_to_modify,
+    breakpoint_lines,
+    code_line_info=None,
+    _pydev_stop_at_break=_pydev_stop_at_break,
+    _pydev_needs_stop_at_break=_pydev_needs_stop_at_break,
+):
     """
     Inserts pydevd programmatic breaks into the code (at the given lines).
 
@@ -268,14 +268,14 @@ def insert_pydevd_breaks(
     for line in breakpoint_lines:
         if line <= 0:
             # The first line is line 1, so, a break at line 0 is not valid.
-            pydev_log.info('Trying to add breakpoint in invalid line: %s', line)
+            pydev_log.info("Trying to add breakpoint in invalid line: %s", line)
             return False, code_to_modify
 
     try:
         b = bytecode.Bytecode.from_code(code_to_modify)
 
         if DEBUG:
-            op_number_bytecode = debug_helper.write_bytecode(b, prefix='bytecode.')
+            op_number_bytecode = debug_helper.write_bytecode(b, prefix="bytecode.")
 
         helper_list = _HelperBytecodeList(b)
 
@@ -286,8 +286,8 @@ def insert_pydevd_breaks(
         last_lineno = None
         while curr_node is not None:
             instruction = curr_node.data
-            instruction_lineno = getattr(instruction, 'lineno', None)
-            curr_name = getattr(instruction, 'name', None)
+            instruction_lineno = getattr(instruction, "lineno", None)
+            curr_name = getattr(instruction, "name", None)
 
             if FIX_PREDICT:
                 predict_targets = _PREDICT_TABLE.get(curr_name)
@@ -297,9 +297,9 @@ def insert_pydevd_breaks(
                     # that it does things the way that ceval actually interprets it.
                     # See: https://mail.python.org/archives/list/python-dev@python.org/thread/CP2PTFCMTK57KM3M3DLJNWGO66R5RVPB/
                     next_instruction = curr_node.next.data
-                    next_name = getattr(next_instruction, 'name', None)
+                    next_name = getattr(next_instruction, "name", None)
                     if next_name in predict_targets:
-                        next_instruction_lineno = getattr(next_instruction, 'lineno', None)
+                        next_instruction_lineno = getattr(next_instruction, "lineno", None)
                         if next_instruction_lineno:
                             next_instruction.lineno = None
 
@@ -323,9 +323,7 @@ def insert_pydevd_breaks(
 
                 if instruction_lineno in modified_breakpoint_lines:
                     added_breaks_in_lines.add(instruction_lineno)
-                    if curr_node.prev is not None and curr_node.prev.data.__class__ == Label \
-                            and curr_name == 'POP_TOP':
-
+                    if curr_node.prev is not None and curr_node.prev.data.__class__ == Label and curr_name == "POP_TOP":
                         # If we have a SETUP_FINALLY where the target is a POP_TOP, we can't change
                         # the target to be the breakpoint instruction (this can crash the interpreter).
 
@@ -333,7 +331,7 @@ def insert_pydevd_breaks(
                             instruction_lineno,
                             _pydev_stop_at_break=_pydev_stop_at_break,
                             _pydev_needs_stop_at_break=_pydev_needs_stop_at_break,
-                            ):
+                        ):
                             curr_node = curr_node.append(new_instruction)
 
                     else:
@@ -341,7 +339,7 @@ def insert_pydevd_breaks(
                             instruction_lineno,
                             _pydev_stop_at_break=_pydev_stop_at_break,
                             _pydev_needs_stop_at_break=_pydev_needs_stop_at_break,
-                            ):
+                        ):
                             curr_node.prepend(new_instruction)
 
             curr_node = curr_node.next
@@ -349,12 +347,12 @@ def insert_pydevd_breaks(
         b[:] = helper_list
 
         if DEBUG:
-            debug_helper.write_bytecode(b, op_number_bytecode, prefix='bytecode.')
+            debug_helper.write_bytecode(b, op_number_bytecode, prefix="bytecode.")
 
         new_code = b.to_code()
 
     except:
-        pydev_log.exception('Error inserting pydevd breaks.')
+        pydev_log.exception("Error inserting pydevd breaks.")
         return False, code_to_modify
 
     if DEBUG:
@@ -362,4 +360,3 @@ def insert_pydevd_breaks(
         debug_helper.write_dis(new_code, op_number)
 
     return True, new_code
-

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

@@ -37,6 +37,7 @@ from _pydevd_frame_eval.vendored.bytecode.concrete import (
 from _pydevd_frame_eval.vendored.bytecode.cfg import BasicBlock, ControlFlowGraph  # noqa
 import sys
 
+
 def dump_bytecode(bytecode, *, lineno=False, stream=sys.stdout):
     def format_line(index, line):
         nonlocal cur_lineno, prev_lineno

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

@@ -176,9 +176,7 @@ class Bytecode(_InstrList, _BaseBytecodeList):
     def _check_instr(self, instr):
         if not isinstance(instr, (Label, SetLineno, Instr)):
             raise ValueError(
-                "Bytecode must only contain Label, "
-                "SetLineno, and Instr objects, "
-                "but %s was found" % type(instr).__name__
+                "Bytecode must only contain Label, " "SetLineno, and Instr objects, " "but %s was found" % type(instr).__name__
             )
 
     def _copy_attr_from(self, bytecode):
@@ -188,6 +186,8 @@ class Bytecode(_InstrList, _BaseBytecodeList):
 
     @staticmethod
     def from_code(code):
+        if sys.version_info[:2] >= (3, 11):
+            raise RuntimeError("This is not updated for Python 3.11 onwards, use only up to Python 3.10!!")
         concrete = _bytecode.ConcreteBytecode.from_code(code)
         return concrete.to_bytecode()
 
@@ -195,9 +195,7 @@ class Bytecode(_InstrList, _BaseBytecodeList):
         cfg = _bytecode.ControlFlowGraph.from_bytecode(self)
         return cfg.compute_stacksize(check_pre_and_post=check_pre_and_post)
 
-    def to_code(
-        self, compute_jumps_passes=None, stacksize=None, *, check_pre_and_post=True
-    ):
+    def to_code(self, compute_jumps_passes=None, stacksize=None, *, check_pre_and_post=True):
         # Prevent reconverting the concrete bytecode to bytecode and cfg to do the
         # calculation if we need to do it.
         if stacksize is None:

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

@@ -21,16 +21,11 @@ class BasicBlock(_bytecode._InstrList):
             index += 1
 
             if not isinstance(instr, (SetLineno, Instr)):
-                raise ValueError(
-                    "BasicBlock must only contain SetLineno and Instr objects, "
-                    "but %s was found" % instr.__class__.__name__
-                )
+                raise ValueError("BasicBlock must only contain SetLineno and Instr objects, " "but %s was found" % instr.__class__.__name__)
 
             if isinstance(instr, Instr) and instr.has_jump():
                 if index < len(self):
-                    raise ValueError(
-                        "Only the last instruction of a basic " "block can be a jump"
-                    )
+                    raise ValueError("Only the last instruction of a basic " "block can be a jump")
 
                 if not isinstance(instr.arg, BasicBlock):
                     raise ValueError(
@@ -135,7 +130,6 @@ def _compute_stack_size(block, size, maxsize, *, check_pre_and_post=True):
     block.startsize = size
 
     for instr in block:
-
         # Ignore SetLineno
         if isinstance(instr, SetLineno):
             continue
@@ -143,11 +137,7 @@ def _compute_stack_size(block, size, maxsize, *, check_pre_and_post=True):
         # For instructions with a jump first compute the stacksize required when the
         # jump is taken.
         if instr.has_jump():
-            effect = (
-                instr.pre_and_post_stack_effect(jump=True)
-                if check_pre_and_post
-                else (instr.stack_effect(jump=True), 0)
-            )
+            effect = instr.pre_and_post_stack_effect(jump=True) if check_pre_and_post else (instr.stack_effect(jump=True), 0)
             taken_size, maxsize = update_size(*effect, size, maxsize)
             # Yield the parameters required to compute the stacksize required
             # by the block to which the jumnp points to and resume when we now
@@ -161,11 +151,7 @@ def _compute_stack_size(block, size, maxsize, *, check_pre_and_post=True):
                 yield maxsize
 
         # jump=False: non-taken path of jumps, or any non-jump
-        effect = (
-            instr.pre_and_post_stack_effect(jump=False)
-            if check_pre_and_post
-            else (instr.stack_effect(jump=False), 0)
-        )
+        effect = instr.pre_and_post_stack_effect(jump=False) if check_pre_and_post else (instr.stack_effect(jump=False), 0)
         size, maxsize = update_size(*effect, size, maxsize)
 
     if block.next_block:
@@ -225,17 +211,11 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
         # Starting with Python 3.10, generator and coroutines start with one object
         # on the stack (None, anything is an error).
         initial_stack_size = 0
-        if sys.version_info >= (3, 10) and self.flags & (
-            CompilerFlags.GENERATOR
-            | CompilerFlags.COROUTINE
-            | CompilerFlags.ASYNC_GENERATOR
-        ):
+        if sys.version_info >= (3, 10) and self.flags & (CompilerFlags.GENERATOR | CompilerFlags.COROUTINE | CompilerFlags.ASYNC_GENERATOR):
             initial_stack_size = 1
 
         # Create a generator/coroutine responsible of dealing with the first block
-        coro = _compute_stack_size(
-            self[0], initial_stack_size, 0, check_pre_and_post=check_pre_and_post
-        )
+        coro = _compute_stack_size(self[0], initial_stack_size, 0, check_pre_and_post=check_pre_and_post)
 
         # Create a list of generator that have not yet been exhausted
         coroutines = []

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

@@ -138,9 +138,7 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList):
     def _check_instr(self, instr):
         if not isinstance(instr, (ConcreteInstr, SetLineno)):
             raise ValueError(
-                "ConcreteBytecode must only contain "
-                "ConcreteInstr and SetLineno objects, "
-                "but %s was found" % type(instr).__name__
+                "ConcreteBytecode must only contain " "ConcreteInstr and SetLineno objects, " "but %s was found" % type(instr).__name__
             )
 
     def _copy_attr_from(self, bytecode):
@@ -236,9 +234,7 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList):
         for lineno, instr in self._normalize_lineno(self, self.first_lineno):
             code_str.append(instr.assemble())
             i_size = instr.size
-            linenos.append(
-                ((offset * 2) if OFFSET_AS_INSTRUCTION else offset, i_size, lineno)
-            )
+            linenos.append(((offset * 2) if OFFSET_AS_INSTRUCTION else offset, i_size, lineno))
             offset += (i_size // 2) if OFFSET_AS_INSTRUCTION else i_size
         code_str = b"".join(code_str)
         return (code_str, linenos)
@@ -254,9 +250,7 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList):
                 continue
             # FIXME: be kind, force monotonic line numbers? add an option?
             if dlineno < 0 and sys.version_info < (3, 6):
-                raise ValueError(
-                    "negative line number delta is not supported " "on Python < 3.6"
-                )
+                raise ValueError("negative line number delta is not supported " "on Python < 3.6")
             old_lineno = lineno
 
             doff = offset - old_offset
@@ -285,7 +279,6 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList):
 
     @staticmethod
     def _pack_linetable(doff, dlineno, linetable):
-
         while dlineno < -127:
             linetable.append(struct.pack("Bb", 0, -127))
             dlineno -= -127
@@ -309,16 +302,15 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList):
         assert 0 <= doff <= 254
         assert -127 <= dlineno <= 127
 
-
     def _assemble_linestable(self, first_lineno, linenos):
         if not linenos:
             return b""
 
         linetable = []
         old_offset = 0
-        
+
         iter_in = iter(linenos)
-        
+
         offset, i_size, old_lineno = next(iter_in)
         old_dlineno = old_lineno - first_lineno
         for offset, i_size, lineno in iter_in:
@@ -442,7 +434,6 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList):
             )
 
     def to_bytecode(self):
-
         # Copy instruction and remove extended args if any (in-place)
         c_instructions = self[:]
         self._remove_extended_args(c_instructions)
@@ -527,7 +518,6 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList):
 
 
 class _ConvertBytecodeToConcrete:
-
     # Default number of passes of compute_jumps() before giving up.  Refer to
     # assemble_jump_offsets() in compile.c for background.
     _compute_jumps_passes = 10
@@ -631,9 +621,7 @@ class _ConvertBytecodeToConcrete:
 
             if instr.opcode in _opcode.hasjrel:
                 instr_offset = offsets[index]
-                target_offset -= instr_offset + (
-                    instr.size // 2 if OFFSET_AS_INSTRUCTION else instr.size
-                )
+                target_offset -= instr_offset + (instr.size // 2 if OFFSET_AS_INSTRUCTION else instr.size)
 
             old_size = instr.size
             # FIXME: better error report if target_offset is negative
@@ -659,9 +647,7 @@ class _ConvertBytecodeToConcrete:
             if not modified:
                 break
         else:
-            raise RuntimeError(
-                "compute_jumps() failed to converge after" " %d passes" % (pas + 1)
-            )
+            raise RuntimeError("compute_jumps() failed to converge after" " %d passes" % (pas + 1))
 
         concrete = ConcreteBytecode(
             self.instructions,

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

@@ -62,22 +62,11 @@ def infer_flags(bytecode, is_async=None):
         bytecode,
         (_bytecode.Bytecode, _bytecode.ConcreteBytecode, _bytecode.ControlFlowGraph),
     ):
-        msg = (
-            "Expected a Bytecode, ConcreteBytecode or ControlFlowGraph "
-            "instance not %s"
-        )
+        msg = "Expected a Bytecode, ConcreteBytecode or ControlFlowGraph " "instance not %s"
         raise ValueError(msg % bytecode)
 
-    instructions = (
-        bytecode.get_instructions()
-        if isinstance(bytecode, _bytecode.ControlFlowGraph)
-        else bytecode
-    )
-    instr_names = {
-        i.name
-        for i in instructions
-        if not isinstance(i, (_bytecode.SetLineno, _bytecode.Label))
-    }
+    instructions = bytecode.get_instructions() if isinstance(bytecode, _bytecode.ControlFlowGraph) else bytecode
+    instr_names = {i.name for i in instructions if not isinstance(i, (_bytecode.SetLineno, _bytecode.Label))}
 
     # Identify optimized code
     if not (instr_names & {"STORE_NAME", "LOAD_NAME", "DELETE_NAME"}):
@@ -97,12 +86,7 @@ def infer_flags(bytecode, is_async=None):
         flags |= CompilerFlags.NOFREE
 
     # Copy flags for which we cannot infer the right value
-    flags |= bytecode.flags & (
-        CompilerFlags.NEWLOCALS
-        | CompilerFlags.VARARGS
-        | CompilerFlags.VARKEYWORDS
-        | CompilerFlags.NESTED
-    )
+    flags |= bytecode.flags & (CompilerFlags.NEWLOCALS | CompilerFlags.VARARGS | CompilerFlags.VARKEYWORDS | CompilerFlags.NESTED)
 
     sure_generator = instr_names & {"YIELD_VALUE"}
     maybe_generator = instr_names & {"YIELD_VALUE", "YIELD_FROM"}
@@ -119,7 +103,6 @@ def infer_flags(bytecode, is_async=None):
     # If performing inference or forcing an async behavior, first inspect
     # the flags since this is the only way to identify iterable coroutines
     if is_async in (None, True):
-
         if bytecode.flags & CompilerFlags.COROUTINE:
             if sure_generator:
                 flags |= CompilerFlags.ASYNC_GENERATOR
@@ -168,9 +151,7 @@ def infer_flags(bytecode, is_async=None):
     else:
         if sure_async:
             raise ValueError(
-                "The is_async argument is False but bytecodes "
-                "that can only be used in async functions have "
-                "been detected."
+                "The is_async argument is False but bytecodes " "that can only be used in async functions have " "been detected."
             )
 
         if maybe_generator:

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

@@ -123,15 +123,10 @@ class FreeVar(_Variable):
 
 def _check_arg_int(name, arg):
     if not isinstance(arg, int):
-        raise TypeError(
-            "operation %s argument must be an int, "
-            "got %s" % (name, type(arg).__name__)
-        )
+        raise TypeError("operation %s argument must be an int, " "got %s" % (name, type(arg).__name__))
 
     if not (0 <= arg <= 2147483647):
-        raise ValueError(
-            "operation %s argument must be in " "the range 0..2,147,483,647" % name
-        )
+        raise ValueError("operation %s argument must be in " "the range 0..2,147,483,647" % name)
 
 
 if sys.version_info < (3, 8):
@@ -174,8 +169,7 @@ class Instr:
     def _check_arg(self, name, opcode, arg):
         if name == "EXTENDED_ARG":
             raise ValueError(
-                "only concrete instruction can contain EXTENDED_ARG, "
-                "highlevel instruction can represent arbitrary argument without it"
+                "only concrete instruction can contain EXTENDED_ARG, " "highlevel instruction can represent arbitrary argument without it"
             )
 
         if opcode >= _opcode.HAVE_ARGUMENT:
@@ -187,41 +181,25 @@ class Instr:
 
         if self._has_jump(opcode):
             if not isinstance(arg, (Label, _bytecode.BasicBlock)):
-                raise TypeError(
-                    "operation %s argument type must be "
-                    "Label or BasicBlock, got %s" % (name, type(arg).__name__)
-                )
+                raise TypeError("operation %s argument type must be " "Label or BasicBlock, got %s" % (name, type(arg).__name__))
 
         elif opcode in _opcode.hasfree:
             if not isinstance(arg, (CellVar, FreeVar)):
-                raise TypeError(
-                    "operation %s argument must be CellVar "
-                    "or FreeVar, got %s" % (name, type(arg).__name__)
-                )
+                raise TypeError("operation %s argument must be CellVar " "or FreeVar, got %s" % (name, type(arg).__name__))
 
         elif opcode in _opcode.haslocal or opcode in _opcode.hasname:
             if not isinstance(arg, str):
-                raise TypeError(
-                    "operation %s argument must be a str, "
-                    "got %s" % (name, type(arg).__name__)
-                )
+                raise TypeError("operation %s argument must be a str, " "got %s" % (name, type(arg).__name__))
 
         elif opcode in _opcode.hasconst:
             if isinstance(arg, Label):
-                raise ValueError(
-                    "label argument cannot be used " "in %s operation" % name
-                )
+                raise ValueError("label argument cannot be used " "in %s operation" % name)
             if isinstance(arg, _bytecode.BasicBlock):
-                raise ValueError(
-                    "block argument cannot be used " "in %s operation" % name
-                )
+                raise ValueError("block argument cannot be used " "in %s operation" % name)
 
         elif opcode in _opcode.hascompare:
             if not isinstance(arg, Compare):
-                raise TypeError(
-                    "operation %s argument type must be "
-                    "Compare, got %s" % (name, type(arg).__name__)
-                )
+                raise TypeError("operation %s argument type must be " "Compare, got %s" % (name, type(arg).__name__))
 
         elif opcode >= _opcode.HAVE_ARGUMENT:
             _check_arg_int(name, arg)
@@ -340,9 +318,7 @@ class Instr:
             return -1, 2
         if _opname == "ROT_N":
             return (-self._arg, self._arg)
-        return {"ROT_TWO": (-2, 2), "ROT_THREE": (-3, 3), "ROT_FOUR": (-4, 4)}.get(
-            _opname, (_effect, 0)
-        )
+        return {"ROT_TWO": (-2, 2), "ROT_THREE": (-3, 3), "ROT_FOUR": (-4, 4)}.get(_opname, (_effect, 0))
 
     def copy(self):
         return self.__class__(self._name, self._arg, lineno=self._lineno, offset=self.offset)

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

@@ -483,9 +483,6 @@ class CodeTransformer:
 
     def code_transformer(self, code, context):
         if sys.flags.verbose:
-            print(
-                "Optimize %s:%s: %s"
-                % (code.co_filename, code.co_firstlineno, code.co_name)
-            )
+            print("Optimize %s:%s: %s" % (code.co_filename, code.co_firstlineno, code.co_name))
         optimizer = PeepholeOptimizer()
         return optimizer.optimize(code)