pydevd-pycharm 241.8102.133__tar.gz → 241.9959.30__tar.gz

{pydevd-pycharm-241.8102.133/pydevd_pycharm.egg-info → pydevd-pycharm-241.9959.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: pydevd-pycharm
-Version: 241.8102.133
+Version: 241.9959.30
 Summary: PyCharm Debugger (used in PyCharm and PyDev)
 Home-page: https://github.com/JetBrains/intellij-community
 Author: JetBrains, Fabio Zadrozny and others

pydevd-pycharm-241.9959.30/VERSION

@@ -0,0 +1 @@
+241.9959.30

pydevd-pycharm-241.9959.30/_pydevd_bundle/pydevd_asyncio_provider.py

@@ -0,0 +1,25 @@
+#  Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+try:
+    from pydevd_nest_asyncio import apply
+except:
+    apply = None
+
+try:
+    from pydevd_asyncio_utils import eval_async_expression_in_context
+except:
+    eval_async_expression_in_context = None
+
+try:
+    from pydevd_asyncio_utils import eval_async_expression
+except:
+    eval_async_expression = None
+
+try:
+    from pydevd_asyncio_utils import exec_async_code
+except:
+    exec_async_code = None
+
+try:
+    from pydevd_asyncio_utils import asyncio_command_compiler
+except:
+    asyncio_command_compiler = None

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_bytecode_utils.py

@@ -1,12 +1,29 @@
-"""Bytecode analysing utils. Originally added for using in smart step into."""
+"""Bytecode analyzing utils that are primarily used for extracting smart steps into
+variants."""
+
 import dis
 import inspect
+import logging
+import os
+import sys
 from collections import namedtuple
 
-from _pydevd_bundle.pydevd_constants import IS_PY3K, IS_CPYTHON
+from _pydevd_bundle.pydevd_constants import IS_PY3K, IS_CPYTHON, IS_PY311_OR_GREATER
+
+__all__ = [
+    'find_last_call_name',
+    'find_last_func_call_order',
+    'get_smart_step_into_candidates',
+]
 
-__all__ = ["find_last_call_name", "find_last_func_call_order",
-           "get_smart_step_into_candidates"]
+_logger = logging.getLogger(__name__)
+DEBUG = os.environ.get('PYCHARM_SMART_STEP_INTO_DEBUG', 'False') == 'True'
+if DEBUG:
+    _logger.setLevel(logging.DEBUG)
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(name)s:%(levelname)s:%(message)s')
+    handler.setFormatter(formatter)
+    _logger.addHandler(handler)
 
 _LOAD_OPNAMES = {
     'LOAD_BUILD_CLASS',
@@ -25,14 +42,16 @@ _CALL_OPNAMES = {
 }
 
 if IS_PY3K:
-    for opname in ('LOAD_CLASSDEREF', 'LOAD_METHOD'):
-        _LOAD_OPNAMES.add(opname)
-    for opname in ('CALL_FUNCTION_EX', 'CALL_METHOD'):
-        _CALL_OPNAMES.add(opname)
+    for each_opname in ('LOAD_CLASSDEREF', 'LOAD_METHOD'):
+        _LOAD_OPNAMES.add(each_opname)
+    for each_opname in ('CALL_FUNCTION_EX', 'CALL_METHOD'):
+        _CALL_OPNAMES.add(each_opname)
+    if IS_PY311_OR_GREATER:
+        _CALL_OPNAMES.add('CALL')
 else:
     _LOAD_OPNAMES.add('LOAD_LOCALS')
-    for opname in ('CALL_FUNCTION_VAR', 'CALL_FUNCTION_VAR_KW'):
-        _CALL_OPNAMES.add(opname)
+    for each_opname in ('CALL_FUNCTION_VAR', 'CALL_FUNCTION_VAR_KW'):
+        _CALL_OPNAMES.add(each_opname)
 
 _BINARY_OPS = set([opname for opname in dis.opname if opname.startswith('BINARY_')])
 
@@ -56,7 +75,8 @@ _BINARY_OP_MAP = {
 if not IS_PY3K:
     _BINARY_OP_MAP['BINARY_DIVIDE'] = '__div__'
 
-_UNARY_OPS = set([opname for opname in dis.opname if opname.startswith('UNARY_') and opname != 'UNARY_NOT'])
+_UNARY_OPS = set([opname for opname in dis.opname if opname.startswith('UNARY_')
+                  and opname != 'UNARY_NOT'])
 
 _UNARY_OP_MAP = {
     'UNARY_POSITIVE': '__pos__',
@@ -98,14 +118,25 @@ def _is_make_opname(opname):
     return opname in _MAKE_OPS
 
 
-# Similar to :py:class:`dis._Instruction` but without fields we don't use. Also :py:class:`dis._Instruction`
-# is not available in Python 2.
-Instruction = namedtuple("Instruction", ["opname", "opcode", "arg", "argval", "lineno", "offset"])
+# A truncated version of the named tuple from the CPython `dis` module that contains
+# only fields necessary for the extraction of stepping variants.
+_Instruction = namedtuple(
+    "_Instruction",
+    [
+        'opname',
+        'opcode',
+        'arg',
+        'argval',
+        'offset',
+        'lineno',
+    ]
+)
 
 if IS_PY3K:
     long = int
 
 try:
+    # noinspection PyProtectedMember,PyUnresolvedReferences
     _unpack_opargs = dis._unpack_opargs
 except AttributeError:
     def _unpack_opargs(code):
@@ -124,64 +155,104 @@ except AttributeError:
                 i += 2
                 if op == dis.EXTENDED_ARG:
                     extended_arg = arg * long(65536)
-            yield (offset, op, arg)
+            yield offset, op, arg
 
 
 def _code_to_name(inst):
-    """If thw instruction's ``argval`` is :py:class:`types.CodeType`, replace it with the name and return the updated instruction.
+    """If the instruction's ``argval`` is :py:class:`types.CodeType`,
+    replace it with the name and return the updated instruction.
 
-    :type inst: :py:class:`Instruction`
-    :rtype: :py:class:`Instruction`
+    :type inst: :py:class:`_Instruction`
+    :rtype: :py:class:`_Instruction`
     """
     if inspect.iscode(inst.argval):
+        # noinspection PyProtectedMember
         return inst._replace(argval=inst.argval.co_name)
     return inst
 
 
-def get_smart_step_into_candidates(code):
-    """Iterate through the bytecode and return a list of instructions which can be smart step into candidates.
+class _BytecodeParsingError(Exception):
+    """Raised when fail of bytecode parsing."""
+    def __init__(self, offset, opname, arg):
+        self.offset = offset
+        self.opname = opname
+        self.arg = arg
+
+    def __str__(self):
+        return "Bytecode parsing error at: offset(%d), opname(%s), arg(%d)" % (
+            self.offset, self.opname, self.arg)
+
 
-    :param code: A code object where we searching for calls.
+def _get_smart_step_into_candidates(code):
+    """Iterate through the bytecode and return a list of instructions which can be
+    smart step into candidates.
+
+    :param code: A code object where we are searching for calls.
     :type code: :py:class:`types.CodeType`
-    :return: list of :py:class:`~Instruction` that represents the objects that were called
-      by one of the Python call instructions.
-    :raise: :py:class:`RuntimeError` if failed to parse the bytecode.
+    :return: list of :py:class:`~_Instruction` that represents the objects that were
+      called by one of the Python call instructions.
+    :raise: :py:class:`_BytecodeParsingError` if failed to parse the bytecode.
     """
     if not IS_CPYTHON:
         # For implementations other than CPython we fall back to simple step into.
+        _logger.debug('Not CPython, returning the empty list of candidates')
         return []
 
     linestarts = dict(dis.findlinestarts(code))
+    _logger.debug('Instructions stating lines: {}'.format(linestarts))
+
     varnames = code.co_varnames
+    _logger.debug('Local variables in function: {}'.format(varnames))
+
     names = code.co_names
+    _logger.debug('Named used by bytecode in function: {}'.format(names))
+
     constants = code.co_consts
+    _logger.debug('Literals used by bytecode in function: {}'.format(constants))
+
     freevars = code.co_freevars
+    _logger.debug('Name of free variables in function: {}'.format(freevars))
+
     lineno = None
-    stk = []  # only the instructions related to calls are pushed in the stack
+    stk = []  # Only the instructions related to calls are pushed in the stack.
     result = []
 
     for offset, op, arg in _unpack_opargs(code.co_code):
+        _logger.debug('-------------------------')
+        _logger.debug('Current instruction stack: {}'.format(stk))
+        _logger.debug('offset[{}] - op[{}={}] - arg[{}]'.format(
+            offset, op, dis.opname[op], arg))
         try:
             if linestarts is not None:
-                lineno = linestarts.get(offset, None) or lineno
+                lineno = linestarts.get(offset, None)
             opname = dis.opname[op]
             argval = None
             if arg is None:
                 if _is_binary_opname(opname):
+                    _logger.debug('Handling binary operator')
                     stk.pop()
-                    result.append(Instruction(opname, op, arg, _BINARY_OP_MAP[opname], lineno, offset))
+                    result.append(_Instruction(
+                        opname, op, arg, _BINARY_OP_MAP[opname], offset, lineno))
                 elif _is_unary_opname(opname):
-                    result.append(Instruction(opname, op, arg, _UNARY_OP_MAP[opname], lineno, offset))
+                    _logger.debug('Handling unary operator')
+                    result.append(_Instruction(
+                        opname, op, arg, _UNARY_OP_MAP[opname], offset, lineno))
             if opname == 'COMPARE_OP':
+                _logger.debug('Handling comparison operation')
                 stk.pop()
                 cmp_op = dis.cmp_op[arg]
                 if cmp_op not in ('exception match', 'BAD'):
-                    result.append(Instruction(opname, op, arg, _COMP_OP_MAP[cmp_op], lineno, offset))
+                    result.append(_Instruction(
+                        opname, op, arg, _COMP_OP_MAP[cmp_op], offset, lineno))
             if _is_load_opname(opname):
+                _logger.debug('Handling load operation')
                 if opname == 'LOAD_CONST':
                     argval = constants[arg]
                 elif opname == 'LOAD_NAME' or opname == 'LOAD_GLOBAL':
-                    argval = names[arg]
+                    if IS_PY311_OR_GREATER:
+                        argval = names[arg >> 1]
+                    else:
+                        argval = names[arg]
                 elif opname == 'LOAD_ATTR':
                     stk.pop()
                     argval = names[arg]
@@ -192,9 +263,11 @@ def get_smart_step_into_candidates(code):
                     argval = names[arg]
                 elif opname == 'LOAD_DEREF':
                     argval = freevars[arg]
-                stk.append(Instruction(opname, op, arg, argval, lineno, offset))
+                stk.append(_Instruction(opname, op, arg, argval, offset, lineno))
             elif _is_make_opname(opname):
-                tos = stk.pop()  # qualified name of the function or function code in Python 2
+                # Qualified name of the function or function code in Python 2.
+                _logger.debug('Handling make operation')
+                tos = stk.pop()
                 argc = 0
                 if IS_PY3K:
                     stk.pop()  # function code
@@ -209,9 +282,12 @@ def get_smart_step_into_candidates(code):
                     argc -= 1
                 stk.append(tos)
             elif _is_call_opname(opname):
+                _logger.debug('Handling call operation')
                 argc = arg  # the number of the function or method arguments
-                if opname == 'CALL_FUNCTION_KW' or not IS_PY3K and opname == 'CALL_FUNCTION_VAR':
-                    stk.pop()  # pop the mapping or iterable with arguments or parameters
+                if (opname == 'CALL_FUNCTION_KW' or not IS_PY3K
+                        and opname == 'CALL_FUNCTION_VAR'):
+                    # Pop the mapping or iterable with arguments or parameters.
+                    stk.pop()
                 elif not IS_PY3K and opname == 'CALL_FUNCTION_VAR_KW':
                     stk.pop()  # pop the mapping with arguments
                     stk.pop()  # pop the iterable with parameters
@@ -231,43 +307,80 @@ def get_smart_step_into_candidates(code):
                 if tos.opname == 'LOAD_BUILD_CLASS':
                     # an internal `CALL_FUNCTION` for building a class
                     continue
-                result.append(tos._replace(offset=offset))  # the actual offset is not when a function was loaded but when it was called
-        except:
-            err_msg = "Bytecode parsing error at: offset(%d), opname(%s), arg(%d)" % (offset, dis.opname[op], arg)
-            raise RuntimeError(err_msg)
+                # The actual offset is not when a function was loaded but when
+                # it was called.
+                _logger.debug('Adding call target from the top of the stack: {}'.
+                              format(tos))
+                result.append(tos._replace(offset=offset))
+        except Exception as e:
+            err = _BytecodeParsingError(offset, dis.opname[op], arg)
+            err.__cause__ = e
+            raise err
     return result
 
 
+def _get_smart_step_into_candidates_311(code):
+    result = []
+    stk = []
+    for instruction in dis.get_instructions(code):
+        if instruction.opname == 'CALL':
+            while stk and stk[-1].opname not in ('LOAD_NAME', 'LOAD_GLOBAL',
+                                                 'LOAD_ATTR', 'LOAD_METHOD'):
+                stk.pop()
+            if not stk:
+                continue
+            tos = stk.pop()
+            result.append(_Instruction(
+                tos.opname,
+                tos.opcode,
+                tos.arg,
+                tos.argval,
+                tos.offset,
+                tos.positions.lineno
+            ))
+        else:
+            stk.append(instruction)
+    return result
+
+
+if IS_PY311_OR_GREATER:
+    get_smart_step_into_candidates = _get_smart_step_into_candidates_311
+else:
+    get_smart_step_into_candidates = _get_smart_step_into_candidates
+
+
 Variant = namedtuple('Variant', ['name', 'is_visited'])
 
 
-def calculate_smart_step_into_variants(frame, start_line, end_line):
-    """
-    Calculate smart step into variants for the given line range.
-    :param frame:
-    :type frame: :py:class:`types.FrameType`
-    :param start_line:
-    :param end_line:
-    :return: A list of call names from the first to the last.
-    :raise: :py:class:`RuntimeError` if failed to parse the bytecode.
-    """
-    variants = []
-    is_context_reached = False
+def find_stepping_targets(frame, start_line, end_line):
+    """Find the *ordered* stepping targets within the given line range."""
+    _logger.debug("Collecting stepping targets for '{}' and line range [{}, {}]".format(
+        frame.f_code.co_name, start_line, end_line))
+    if DEBUG:
+        _logger.debug('The disassembled version of the code:')
+        dis.dis(frame.f_code, file=sys.stderr)
+    stepping_targets = []
+    is_within_range = False
     code = frame.f_code
-    lasti = frame.f_lasti
+    last_instruction = frame.f_lasti
+    _logger.debug('Last executed instruction offset is {}'.format(last_instruction))
     for inst in get_smart_step_into_candidates(code):
+        _logger.debug('Checking {} smart step into candidate'.format(inst))
         if inst.lineno and inst.lineno > end_line:
             break
-        if not is_context_reached and inst.lineno is not None and inst.lineno >= start_line:
-            is_context_reached = True
-        if not is_context_reached:
+        if (not is_within_range and inst.lineno is not None
+                and inst.lineno >= start_line):
+            is_within_range = True
+        if not is_within_range:
             continue
-        variants.append(Variant(inst.argval, inst.offset <= lasti))
-    return variants
+        stepping_targets.append(Variant(inst.argval, inst.offset < last_instruction))
+    _logger.debug('Found stepping targets: {}'.format(stepping_targets))
+    return stepping_targets
 
 
 def find_last_func_call_order(frame, start_line):
-    """Find the call order of the last function call between ``start_line`` and last executed instruction.
+    """Find the call order of the last function call between ``start_line``
+    and last executed instruction.
 
     :param frame: A frame inside which we are looking the function call.
     :type frame: :py:class:`types.FrameType`
@@ -303,9 +416,9 @@ def find_last_call_name(frame):
     """
     last_call_name = None
     code = frame.f_code
-    lasti = frame.f_lasti
+    last_instruction = frame.f_lasti
     for inst in get_smart_step_into_candidates(code):
-        if inst.offset > lasti:
+        if inst.offset > last_instruction:
             break
         last_call_name = inst.argval
 

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_comm.py

@@ -148,7 +148,7 @@ from _pydevd_bundle.pydevd_comm_constants import (
 MAX_IO_MSG_SIZE = 1000  #if the io is too big, we'll not send all (could make the debugger too non-responsive)
 #this number can be changed if there's need to do so
 
-VERSION_STRING = "241.8102.133"
+VERSION_STRING = "241.9959.30"
 
 from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
 file_system_encoding = getfilesystemencoding()
@@ -291,6 +291,8 @@ class ReaderThread(PyDBDaemonThread):
             while not self.killReceived:
                 try:
                     r = self.sock.recv(1024)
+                except OSError:
+                    return
                 except:
                     if not self.killReceived:
                         traceback.print_exc()
@@ -1477,7 +1479,7 @@ class InternalGetSmartStepIntoVariants(InternalThreadCommand):
     def do_it(self, dbg):
         try:
             frame = pydevd_vars.find_frame(self.thread_id, self.frame_id)
-            variants = pydevd_bytecode_utils.calculate_smart_step_into_variants(frame, self.start_line, self.end_line)
+            variants = pydevd_bytecode_utils.find_stepping_targets(frame, self.start_line, self.end_line)
             xml = "<xml>"
 
             for name, is_visited in variants:

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_console_integration.py

@@ -16,10 +16,7 @@ from _pydev_bundle.pydev_console_types import CodeFragment, Command
 from _pydev_bundle.pydev_imports import Exec
 from _pydevd_bundle import pydevd_vars, pydevd_save_locals
 from _pydevd_bundle.pydevd_console_pytest import enable_pytest_output
-from _pydevd_bundle.pydevd_constants import IS_ASYNCIO_DEBUGGER_ENV
-from _pydevd_asyncio_util.pydevd_asyncio_utils import asyncio_command_compiler, exec_async_code
-if IS_ASYNCIO_DEBUGGER_ENV:
-    from _pydevd_asyncio_util.pydevd_nest_asyncio import apply
+from _pydevd_bundle.pydevd_asyncio_provider import asyncio_command_compiler, exec_async_code, apply
 
 try:
     import __builtin__
@@ -195,7 +192,7 @@ def console_exec(thread_id, frame_id, expression, dbg):
         enable_pytest_output()
 
     if IPYTHON:
-        if IS_ASYNCIO_DEBUGGER_ENV:
+        if apply is not None:
             apply()
         need_more, exception_occurred = ipython_exec_code(CodeFragment(expression), updated_globals, updated_globals, dbg)
         if not need_more:
@@ -205,7 +202,7 @@ def console_exec(thread_id, frame_id, expression, dbg):
     interpreter = ConsoleWriter()
 
     try:
-        if IS_ASYNCIO_DEBUGGER_ENV:
+        if asyncio_command_compiler is not None:
             compiler = asyncio_command_compiler
         else:
             compiler = compile_command
@@ -226,7 +223,7 @@ def console_exec(thread_id, frame_id, expression, dbg):
     code_executor.interruptable = True
     exception_occurred = False
     try:
-        if IS_ASYNCIO_DEBUGGER_ENV:
+        if exec_async_code is not None:
             exec_async_code(code, updated_globals)
         else:
             # It is important that globals and locals we pass to the exec function are the same object.

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_constants.py

@@ -197,7 +197,6 @@ NEXT_VALUE_SEPARATOR = "__pydev_val__"
 BUILTINS_MODULE_NAME = '__builtin__' if IS_PY2 else 'builtins'
 SHOW_DEBUG_INFO_ENV = os.getenv('PYCHARM_DEBUG') == 'True' or os.getenv('PYDEV_DEBUG') == 'True'
 IS_ASYNCIO_REPL = os.getenv('ASYNCIO_REPL') == 'True' and IS_PY38_OR_GREATER
-IS_ASYNCIO_DEBUGGER_ENV = os.getenv('ASYNCIO_DEBUGGER_ENV') == 'True' and IS_PY38_OR_GREATER
 
 # If True, CMD_SET_NEXT_STATEMENT and CMD_RUN_TO_LINE commands have responses indicating success or failure.
 GOTO_HAS_RESPONSE = IS_PYCHARM

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_dont_trace_files.py

@@ -72,7 +72,6 @@ DONT_TRACE = {
     'pydevd.py': PYDEV_FILE,
     'pydevd_additional_thread_info.py': PYDEV_FILE,
     'pydevd_additional_thread_info_regular.py': PYDEV_FILE,
-    'pydevd_asyncio_utils.py': PYDEV_FILE,
     'pydevd_breakpointhook.py': PYDEV_FILE,
     'pydevd_breakpoints.py': PYDEV_FILE,
     'pydevd_bytecode_utils.py': PYDEV_FILE,
@@ -107,9 +106,9 @@ DONT_TRACE = {
     'pydevd_ipython_console_output.py': PYDEV_FILE,
     'pydevd_kill_all_pydevd_threads.py': PYDEV_FILE,
     'pydevd_modify_bytecode.py': PYDEV_FILE,
-    'pydevd_nest_asyncio.py': PYDEV_FILE,
     'pydevd_pandas.py': PYDEV_FILE,
     'pydevd_pep_669_tracing.py': PYDEV_FILE,
+    'pydevd_numpy.py': PYDEV_FILE,
     'pydevd_pep_669_tracing_wrapper.py': PYDEV_FILE,
     'pydevd_plugin_numpy_types.py': PYDEV_FILE,
     'pydevd_plugin_utils.py': PYDEV_FILE,
@@ -141,6 +140,11 @@ DONT_TRACE = {
     'test_common.py': PYDEV_FILE,
     'test_pandas.py': PYDEV_FILE,
     'test_pydev_pandas.py': PYDEV_FILE,
+    'test_pydev_nparray.py': PYDEV_FILE,
+    'pydevd_nest_asyncio.py': PYDEV_FILE,
+    'pydevd_asyncio_constants.py': PYDEV_FILE,
+    'pydevd_asyncio_provider.py': PYDEV_FILE,
+    'pydevd_asyncio_utils.py': PYDEV_FILE,
 }
 
 DONT_TRACE['pydev_jupyter_plugin.py'] = PYDEV_FILE

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_tables.py

@@ -66,9 +66,11 @@ def __get_table_provider(output):
     table_provider = None
     type_qualified_name = '{}.{}'.format(output_type.__module__, output_type.__name__)
     if type_qualified_name in ['pandas.core.frame.DataFrame',
-                               'pandas.core.series.Series',
-                               'numpy.ndarray']:
+                               'pandas.core.series.Series']:
         import _pydevd_bundle.tables.pydevd_pandas as table_provider
+    # dict is needed for sort commands
+    elif type_qualified_name in ['numpy.ndarray', 'builtins.dict']:
+        import _pydevd_bundle.tables.pydevd_numpy as table_provider
     elif type_qualified_name.startswith('polars') and (
             type_qualified_name.endswith('DataFrame')
             or type_qualified_name.endswith('Series')):

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_utils.py

@@ -17,11 +17,11 @@ except:
 
 import inspect
 from _pydevd_bundle.pydevd_constants import BUILTINS_MODULE_NAME, IS_PY38_OR_GREATER, dict_iter_items, get_global_debugger, IS_PY3K, LOAD_VALUES_POLICY, \
-    ValuesPolicy, GET_FRAME_RETURN_GROUP, GET_FRAME_NORMAL_GROUP, IS_ASYNCIO_DEBUGGER_ENV, IS_PY311
+    ValuesPolicy, GET_FRAME_RETURN_GROUP, GET_FRAME_NORMAL_GROUP, IS_PY311
 import sys
 from _pydev_bundle import pydev_log
 from _pydev_imps._pydev_saved_modules import threading
-from _pydevd_asyncio_util.pydevd_asyncio_utils import eval_async_expression_in_context
+from _pydevd_bundle.pydevd_asyncio_provider import eval_async_expression_in_context
 from array import array
 from collections import deque
 
@@ -638,7 +638,7 @@ def is_current_thread_main_thread():
 
 
 def eval_expression(expression, globals, locals):
-    if IS_ASYNCIO_DEBUGGER_ENV:
+    if eval_async_expression_in_context is not None:
         return eval_async_expression_in_context(expression, globals, locals, False)
     else:
         return eval(expression, globals, locals)

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_vars.py

@@ -6,11 +6,11 @@ import pickle
 
 from _pydev_bundle.pydev_imports import quote
 from _pydev_imps._pydev_saved_modules import thread
-from _pydevd_bundle.pydevd_constants import get_frame, get_current_thread_id, xrange, NUMPY_NUMERIC_TYPES, NUMPY_FLOATING_POINT_TYPES, IS_ASYNCIO_DEBUGGER_ENV
+from _pydevd_bundle.pydevd_constants import get_frame, get_current_thread_id, xrange, NUMPY_NUMERIC_TYPES, NUMPY_FLOATING_POINT_TYPES
 from _pydevd_bundle.pydevd_custom_frames import get_custom_frame
 from _pydevd_bundle.pydevd_user_type_renderers_utils import try_get_type_renderer_for_var
 from _pydevd_bundle.pydevd_xml import ExceptionOnEvaluate, get_type, var_to_xml
-from _pydevd_asyncio_util.pydevd_asyncio_utils import eval_async_expression, eval_async_expression_in_context
+from _pydevd_bundle.pydevd_asyncio_provider import eval_async_expression
 
 try:
     from StringIO import StringIO
@@ -457,7 +457,7 @@ def evaluate_expression(thread_id, frame_id, expression, doExec):
     try:
         expression = str(expression.replace('@LINE@', '\n'))
 
-        if IS_ASYNCIO_DEBUGGER_ENV:
+        if eval_async_expression is not None:
             return eval_async_expression(expression, updated_globals, frame, doExec, get_eval_exception_msg)
 
         if doExec:

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/pydevd.py

@@ -32,7 +32,7 @@ from _pydevd_bundle.pydevd_constants import IS_JYTH_LESS25, IS_PYCHARM, get_thre
     clear_cached_thread_id, INTERACTIVE_MODE_AVAILABLE, SHOW_DEBUG_INFO_ENV, \
     IS_PY34_OR_GREATER, IS_PY36_OR_GREATER, \
     IS_PY2, NULL, NO_FTRACE, dummy_excepthook, IS_CPYTHON, GOTO_HAS_RESPONSE, \
-    IS_ASYNCIO_DEBUGGER_ENV, USE_LOW_IMPACT_MONITORING
+    USE_LOW_IMPACT_MONITORING
 from _pydev_bundle import fix_getpass
 from _pydev_bundle import pydev_imports, pydev_log
 from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
@@ -1520,8 +1520,8 @@ class PyDB(object):
         if set_trace:
             self.enable_tracing()
 
-        if IS_ASYNCIO_DEBUGGER_ENV:
-            from _pydevd_asyncio_util.pydevd_nest_asyncio import apply
+        from _pydevd_bundle.pydevd_asyncio_provider import apply
+        if apply is not None:
             apply()
 
         return self._exec(is_module, entry_point_fn, module_name, file, globals, locals)

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30/pydevd_pycharm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: pydevd-pycharm
-Version: 241.8102.133
+Version: 241.9959.30
 Summary: PyCharm Debugger (used in PyCharm and PyDev)
 Home-page: https://github.com/JetBrains/intellij-community
 Author: JetBrains, Fabio Zadrozny and others

{pydevd-pycharm-241.8102.133 → pydevd-pycharm-241.9959.30}/pydevd_pycharm.egg-info/SOURCES.txt

@@ -62,13 +62,11 @@ _pydev_runfiles/pydev_runfiles_parallel_client.py
 _pydev_runfiles/pydev_runfiles_pytest2.py
 _pydev_runfiles/pydev_runfiles_unittest.py
 _pydev_runfiles/pydev_runfiles_xml_rpc.py
-_pydevd_asyncio_util/__init__.py
-_pydevd_asyncio_util/pydevd_asyncio_utils.py
-_pydevd_asyncio_util/pydevd_nest_asyncio.py
 _pydevd_bundle/__init__.py
 _pydevd_bundle/pydevconsole_code_for_ironpython.py
 _pydevd_bundle/pydevd_additional_thread_info.py
 _pydevd_bundle/pydevd_additional_thread_info_regular.py
+_pydevd_bundle/pydevd_asyncio_provider.py
 _pydevd_bundle/pydevd_breakpointhook.py
 _pydevd_bundle/pydevd_breakpoints.py
 _pydevd_bundle/pydevd_bytecode_utils.py