pydevd-pycharm 242.18071.12__tar.gz → 242.20224.89__tar.gz

pydevd-pycharm-242.20224.89/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.1
+Name: pydevd-pycharm
+Version: 242.20224.89
+Summary: PyCharm Debugger (used in PyCharm and PyDev)
+Home-page: https://github.com/JetBrains/intellij-community
+Author: JetBrains, Fabio Zadrozny and others
+License: Apache 2.0
+Keywords: pydev,pydevd,pydev.debugger,pycharm
+Platform: UNKNOWN
+Classifier: Development Status :: 6 - Mature
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Debuggers
+License-File: LICENSE
+
+PyDev.Debugger
+==============
+
+The sources for the PyDev.Debugger (used in PyDev & PyCharm) may be seen at:
+
+https://github.com/fabioz/PyDev.Debugger
+
+In general, the debugger backend should **NOT** be installed separately if you're using an IDE which already
+bundles it (such as PyDev or PyCharm).
+
+It is however available in PyPi so that it can be installed for doing remote debugging with `pip` -- so, when
+debugging a process which runs in another machine, it's possible to `pip install pydevd-pycharm` and in the code use
+`pydevd_pycharm.settrace(host='10.1.1.1')` to connect the debugger backend to the debugger UI running in the IDE
+(whereas previously the sources had to be manually copied from the IDE installation).
+
+It should be compatible with Python 2.6 onwards (as well as Jython 2.7, IronPython and PyPy -- and
+any other variant which properly supports the Python structure for debuggers -- i.e.: sys.settrace/threading.settrace).
+
+Recent versions contain speedup modules using Cython, which are generated with a few changes in the regular files
+to `cythonize` the files. To update and compile the cython sources (and generate some other auto-generated files),
+`build_tools/build.py` should be run -- note that the resulting .pyx and .c files should be commited.
+
+To generate a distribution with the precompiled binaries for the IDE, `build_binaries_windows.py` should be run (
+note that the environments must be pre-created as specified in that file).
+
+To generate a distribution to upload to PyPi, `python setup.py sdist bdist_wheel` should be run for each python version
+which should have a wheel and afterwards `twine upload -s dist/pydevd-*` should be run to actually upload the contents
+to PyPi.
+
+Travis (Linux CI):
+
+.. |travis| image:: https://travis-ci.org/fabioz/PyDev.Debugger.png
+  :target: https://travis-ci.org/fabioz/PyDev.Debugger
+
+|travis|
+
+Appveyor (Windows CI):
+
+.. |appveyor| image:: https://ci.appveyor.com/api/projects/status/j6vjq687brbk20ux?svg=true
+  :target: https://ci.appveyor.com/project/fabioz/pydev-debugger
+
+|appveyor|
+
+
+

pydevd-pycharm-242.20224.89/VERSION

@@ -0,0 +1 @@
+242.20224.89

pydevd-pycharm-242.20224.89/_pydev_bundle/pydev_is_thread_alive.py

@@ -0,0 +1,32 @@
+from _pydev_imps._pydev_saved_modules import threading
+
+# Hack for https://www.brainwy.com/tracker/PyDev/363
+# I.e.: calling isAlive() can throw AssertionError under some circumstances
+# It is required to debug threads started by start_new_thread in Python 3.4
+_temp = threading.Thread()
+
+# Python <=3.12
+if hasattr(_temp, '_is_stopped'):
+    def is_thread_alive(t):
+        return not t._is_stopped
+
+# Python 2.x
+elif hasattr(_temp, '_Thread__stopped'):
+    def is_thread_alive(t):
+        return not t._Thread__stopped
+
+# Jython wraps a native java thread and thus only obeys the public API
+elif hasattr(_temp, 'isAlive'):
+    def is_thread_alive(t):
+        return t.isAlive()
+
+# Python >=3.13
+elif hasattr(_temp, 'is_alive'):
+    def is_thread_alive(t):
+        return t.is_alive()
+
+else:
+    def is_thread_alive(t):
+        raise RuntimeError('Cannot determine how to check if thread is alive')
+
+del _temp

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/_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 = "242.18071.12"
+VERSION_STRING = "242.20224.89"
 
 from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
 file_system_encoding = getfilesystemencoding()
@@ -270,9 +270,7 @@ class ReaderThread(PyDBDaemonThread):
         self.name = "pydevd.Reader"
         from _pydevd_bundle.pydevd_process_net_command import process_net_command
         self.process_net_command = process_net_command
-        self.global_debugger_holder = GlobalDebuggerHolder
-
-
+        self.debugger = GlobalDebuggerHolder.global_dbg
 
     def do_kill_pydev_thread(self):
         #We must close the socket so that it doesn't stay halted there.
@@ -330,12 +328,11 @@ class ReaderThread(PyDBDaemonThread):
             traceback.print_exc()
             self.handle_except()
 
-
     def handle_except(self):
-        self.global_debugger_holder.global_dbg.finish_debugging_session()
+        self.debugger.finish_debugging_session()
 
     def process_command(self, cmd_id, seq, text):
-        self.process_net_command(self.global_debugger_holder.global_dbg, cmd_id, seq, text)
+        self.process_net_command(self.debugger, cmd_id, seq, text)
 
 
 #----------------------------------------------------------------------------------- SOCKET UTILITIES - WRITER

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/_pydevd_bundle/pydevd_frame_type_handler.py

@@ -1,4 +1,6 @@
 #  Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+import threading
+
 from _pydevd_bundle.pydevd_constants import RETURN_VALUES_DICT, dict_iter_items, \
     GET_FRAME_NORMAL_GROUP, GET_FRAME_SPECIAL_GROUP
 
@@ -172,19 +174,36 @@ THRIFT_COMMUNICATION_VARS_HANDLER = 1
 
 
 class VarsHandlerContainer:
-    _instance_xml_handler = None
-    _instance_thrift_handler = None
+    instance_xml_handler = None
+    instance_thrift_handler = None
+
+
+_vars_handler_initialization_lock = threading.RLock()
+
+
+def _init_xml_communication_vars_handler(func, handler_type):
+    with _vars_handler_initialization_lock:
+        if VarsHandlerContainer.instance_xml_handler is None:
+            VarsHandlerContainer.instance_xml_handler = \
+                VarsHandler(func, handler_type)
+
+
+def _init_thrift_communication_var_handler(func, handler_type):
+    with _vars_handler_initialization_lock:
+        if VarsHandlerContainer.instance_thrift_handler is None:
+            VarsHandlerContainer.instance_thrift_handler = \
+                VarsHandler(func, handler_type)
 
 
 def get_vars_handler(func, handler_type, group_type):
     if handler_type == XML_COMMUNICATION_VARS_HANDLER:
-        if VarsHandlerContainer._instance_xml_handler is None:
-            VarsHandlerContainer._instance_xml_handler = VarsHandler(func, handler_type)
-        return VarsHandlerContainer._instance_xml_handler.get_instance(group_type)
+        if VarsHandlerContainer.instance_xml_handler is None:
+            _init_xml_communication_vars_handler(func, handler_type)
+        return VarsHandlerContainer.instance_xml_handler.get_instance(group_type)
     elif handler_type == THRIFT_COMMUNICATION_VARS_HANDLER:
-        if VarsHandlerContainer._instance_thrift_handler is None:
-            VarsHandlerContainer._instance_thrift_handler = VarsHandler(func, handler_type)
-        return VarsHandlerContainer._instance_thrift_handler.get_instance(group_type)
+        if VarsHandlerContainer.instance_thrift_handler is None:
+            _init_thrift_communication_var_handler(func, handler_type)
+        return VarsHandlerContainer.instance_thrift_handler.get_instance(group_type)
 
 
 class VarsHandler:
@@ -194,23 +213,26 @@ class VarsHandler:
         self._instance_special = None
         self._instance_return = None
         self.handler_type = handler_type
+        self._lock = threading.RLock()
 
     def get_instance(self, group_type):
-        if group_type == GET_FRAME_NORMAL_GROUP:
-            if self._instance_normal is None:
-                self._init_normal()
-            instance = self._instance_normal
-        elif group_type == GET_FRAME_SPECIAL_GROUP:
-            if self._instance_special is None:
-                self._init_special()
-            instance = self._instance_special
-        else:
-            if self._instance_return is None:
-                self._init_return()
-            instance = self._instance_return
+        with self._lock:
+            if group_type == GET_FRAME_NORMAL_GROUP:
+                if self._instance_normal is None:
+                    self._init_normal()
+                instance = self._instance_normal
+            elif group_type == GET_FRAME_SPECIAL_GROUP:
+                if self._instance_special is None:
+                    self._init_special()
+                instance = self._instance_special
+            else:
+                if self._instance_return is None:
+                    self._init_return()
+                instance = self._instance_return
+
+            instance.update_handlers()
 
-        instance.update_handlers()
-        return instance
+            return instance
 
     def _init_normal(self):
         self._instance_normal = DummyVarHandler(

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/_pydevd_bundle/pydevd_tables.py

@@ -10,7 +10,7 @@ class TableCommandType:
     DF_INFO = "DF_INFO"
     SLICE = "SLICE"
     DESCRIBE = "DF_DESCRIBE"
-    HISTOGRAM_DATA = "HISTOGRAM_DATA"
+    VISUALIZATION_DATA = "VISUALIZATION_DATA"
 
 
 def is_error_on_eval(val):
@@ -47,10 +47,8 @@ def exec_table_command(init_command, command_type, start_index, end_index, f_glo
 
     elif command_type == TableCommandType.DESCRIBE:
         res.append(table_provider.get_column_descriptions(table))
-        res.append(NEXT_VALUE_SEPARATOR)
-        res.append(table_provider.get_value_counts(table))
 
-    elif command_type == TableCommandType.HISTOGRAM_DATA:
+    elif command_type == TableCommandType.VISUALIZATION_DATA:
         res.append(table_provider.get_value_occurrences_count(table))
         res.append(NEXT_VALUE_SEPARATOR)
 
@@ -70,6 +68,7 @@ def __get_table_provider(output):
     if type_qualified_name in ['pandas.core.frame.DataFrame',
                                'pandas.core.series.Series',
                                'geopandas.geoseries.GeoSeries',
+                               'geopandas.geodataframe.GeoDataFrame',
                                'pandera.typing.pandas.DataFrame']:
         import _pydevd_bundle.tables.pydevd_pandas as table_provider
     # dict is needed for sort commands
@@ -84,5 +83,7 @@ def __get_table_provider(output):
             type_qualified_name.endswith('DataFrame')
             or type_qualified_name.endswith('Series')):
         import _pydevd_bundle.tables.pydevd_polars as table_provider
+    elif type_qualified_name == 'datasets.arrow_dataset.Dataset':
+        import _pydevd_bundle.tables.pydevd_dataset as table_provider
 
     return table_provider

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/_pydevd_bundle/pydevd_thrift.py

@@ -17,7 +17,7 @@ from _pydevd_bundle.pydevd_extension_api import TypeResolveProvider, StrPresenta
 from _pydevd_bundle.pydevd_user_type_renderers_utils import try_get_type_renderer_for_var
 from _pydevd_bundle.pydevd_utils import  is_string, should_evaluate_full_value, should_evaluate_shape
 from _pydevd_bundle.pydevd_vars import get_label, array_default_format, is_able_to_format_number, MAXIMUM_ARRAY_SIZE, \
-    get_column_formatter_by_type, get_formatted_row_elements, DEFAULT_DF_FORMAT, DATAFRAME_HEADER_LOAD_MAX_SIZE
+    get_column_formatter_by_type, get_formatted_row_elements, IAtPolarsAccessor, DEFAULT_DF_FORMAT, DATAFRAME_HEADER_LOAD_MAX_SIZE
 from pydev_console.pydev_protocol import DebugValue, GetArrayResponse, ArrayData, ArrayHeaders, ColHeader, RowHeader, \
     UnsupportedArrayTypeException, ExceedingArrayDimensionsException
 from _pydevd_bundle.pydevd_xml import ExceptionOnEvaluate
@@ -420,6 +420,10 @@ def sparse_tensor_to_thrift_struct(tensor, name, roffset, coffset, rows, cols, f
         pass
 
 
+def dataset_to_thrift_struct(dataset, name, roffset, coffset, rows, cols, format):
+    return dataframe_to_thrift_struct(dataset.to_pandas(), name, roffset, coffset, rows, cols, format)
+
+
 def array_to_meta_thrift_struct(array, name, format):
     type = array.dtype.kind
     slice = name
@@ -501,7 +505,7 @@ def dataframe_to_thrift_struct(df, name, roffset, coffset, rows, cols, format):
 
     """
     original_df = df
-    dim = len(df.axes)
+    dim = len(df.axes) if hasattr(df, 'axes') else -1
     num_rows = df.shape[0]
     num_cols = df.shape[1] if dim > 1 else 1
     array_chunk = GetArrayResponse()
@@ -519,7 +523,7 @@ def dataframe_to_thrift_struct(df, name, roffset, coffset, rows, cols, format):
             except AttributeError:
                 try:
                     kind = df.dtypes[0].kind
-                except (IndexError, KeyError):
+                except (IndexError, KeyError, AttributeError):
                     kind = "O"
             format = array_default_format(kind)
         else:
@@ -552,19 +556,34 @@ def dataframe_to_thrift_struct(df, name, roffset, coffset, rows, cols, format):
             else:
                 bounds = (0, 0)
             col_bounds[col] = bounds
+    elif dim == -1:
+        dtype = '0'
+        dtypes[0] = dtype
+        col_bounds[0] = (df.min(), df.max()) if dtype in NUMPY_NUMERIC_TYPES and df.size != 0 else (0, 0)
     else:
         dtype = df.dtype.kind
         dtypes[0] = dtype
         col_bounds[0] = (df.min(), df.max()) if dtype in NUMPY_NUMERIC_TYPES and df.size != 0 else (0, 0)
 
-    df = df.iloc[roffset: roffset + rows, coffset: coffset + cols] if dim > 1 else df.iloc[roffset: roffset + rows]
+    if dim > 1:
+        df = df.iloc[roffset: roffset + rows, coffset: coffset + cols]
+    elif dim == -1:
+        df = df[roffset: roffset + rows]
+    else:
+        df.iloc[roffset: roffset + rows]
+
     rows = df.shape[0]
     cols = df.shape[1] if dim > 1 else 1
 
     def col_to_format(c):
         return get_column_formatter_by_type(format, dtypes[c])
 
-    iat = df.iat if dim == 1 or len(df.columns.unique()) == len(df.columns) else df.iloc
+    if dim == -1:
+        iat = IAtPolarsAccessor(df)
+    elif dim == 1 or len(df.columns.unique()) == len(df.columns):
+        iat = df.iat
+    else:
+        iat = df.iloc
 
     def formatted_row_elements(row):
         return get_formatted_row_elements(row, iat, dim, cols, format, dtypes)
@@ -606,7 +625,7 @@ def header_data_to_thrift_struct(rows, cols, dtypes, col_bounds, col_to_format,
     for row in range(rows):
         row_header = RowHeader()
         row_header.index = row
-        row_header.label = get_label(df.axes[0].values[row])
+        row_header.label = get_label(df.axes[0].values[row] if dim != -1 else str(row))
         row_headers.append(row_header)
     array_headers.colHeaders = col_headers
     array_headers.rowHeaders = row_headers
@@ -621,6 +640,7 @@ TYPE_TO_THRIFT_STRUCT_CONVERTERS = {
     "Tensor": tensor_to_thrift_struct,
     "DataFrame": dataframe_to_thrift_struct,
     "Series": dataframe_to_thrift_struct,
+    "Dataset": dataset_to_thrift_struct,
     "GeoDataFrame": dataframe_to_thrift_struct,
     "GeoSeries": dataframe_to_thrift_struct
 }

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/_pydevd_bundle/pydevd_utils.py

@@ -627,6 +627,25 @@ def should_evaluate_shape():
     return LOAD_VALUES_POLICY != ValuesPolicy.ON_DEMAND
 
 
+def is_safe_to_access(obj, attr_name):
+    """Evaluates the safety of attribute accessibility via `obj.attr_name`.
+
+    Direct attribute access can occasionally lead to unsafe conditions. A typical
+    scenario is when an extension class contains a property that might attempt to
+    access a field before its initialization. This function aims to verify the safety
+    of attribute access in the most risk-free manner. As an example, it leverages the
+    `inspect` module, facilitating attribute retrieval without triggering any
+    descriptor functionality.
+    """
+    attr = inspect.getattr_static(obj, attr_name, None)
+
+    # Should we check for other descriptor types here?
+    if inspect.isgetsetdescriptor(attr):
+        return False
+
+    return True
+
+
 def is_in_unittests_debugging_mode():
     debugger = get_global_debugger()
     if debugger:

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/_pydevd_bundle/pydevd_vars.py

@@ -693,6 +693,13 @@ def get_label(label):
 
 DATAFRAME_HEADER_LOAD_MAX_SIZE = 100
 
+class IAtPolarsAccessor:
+    def __init__(self, ps):
+        self.ps = ps
+
+    def __getitem__(self, row):
+        return self.ps[row]
+
 
 def dataframe_to_xml(df, name, roffset, coffset, rows, cols, format):
     """
@@ -707,7 +714,7 @@ def dataframe_to_xml(df, name, roffset, coffset, rows, cols, format):
 
     """
     original_df = df
-    dim = len(df.axes)
+    dim = len(df.axes) if hasattr(df, 'axes') else -1
     num_rows = df.shape[0]
     num_cols = df.shape[1] if dim > 1 else 1
     format = format.replace('%', '')
@@ -719,7 +726,7 @@ def dataframe_to_xml(df, name, roffset, coffset, rows, cols, format):
             except AttributeError:
                 try:
                     kind = df.dtypes[0].kind
-                except (IndexError, KeyError):
+                except (IndexError, KeyError, AttributeError):
                     kind = 'O'
             format = array_default_format(kind)
         else:
@@ -752,19 +759,34 @@ def dataframe_to_xml(df, name, roffset, coffset, rows, cols, format):
             else:
                 bounds = (0, 0)
             col_bounds[col] = bounds
+    elif dim == -1:
+        dtype = '0'
+        dtypes[0] = dtype
+        col_bounds[0] = (df.min(), df.max()) if dtype in NUMPY_NUMERIC_TYPES and df.size != 0 else (0, 0)
     else:
         dtype = df.dtype.kind
         dtypes[0] = dtype
         col_bounds[0] = (df.min(), df.max()) if dtype in NUMPY_NUMERIC_TYPES and df.size != 0 else (0, 0)
 
-    df = df.iloc[roffset: roffset + rows, coffset: coffset + cols] if dim > 1 else df.iloc[roffset: roffset + rows]
+    if dim > 1:
+        df = df.iloc[roffset: roffset + rows, coffset: coffset + cols]
+    elif dim == -1:
+        df = df[roffset: roffset + rows]
+    else:
+        df.iloc[roffset: roffset + rows]
+
     rows = df.shape[0]
     cols = df.shape[1] if dim > 1 else 1
 
     def col_to_format(column_type):
         return get_column_formatter_by_type(format, column_type)
 
-    iat = df.iat if dim == 1 or len(df.columns.unique()) == len(df.columns) else df.iloc
+    if dim == -1:
+        iat = IAtPolarsAccessor(df)
+    elif dim == 1 or len(df.columns.unique()) == len(df.columns):
+        iat = df.iat
+    else:
+        iat = df.iloc
 
     def formatted_row_elements(row):
         return get_formatted_row_elements(row, iat, dim, cols, format, dtypes)
@@ -774,6 +796,9 @@ def dataframe_to_xml(df, name, roffset, coffset, rows, cols, format):
     xml += array_data_to_xml(rows, cols, formatted_row_elements, format)
     return xml
 
+def dataset_to_xml(dataset, name, roffset, coffset, rows, cols, format):
+    return dataframe_to_xml(dataset.to_pandas(), name, roffset, coffset, rows, cols, format)
+
 
 def array_data_to_xml(rows, cols, get_row, format):
     xml = "<arraydata rows=\"%s\" cols=\"%s\"/>\n" % (rows, cols)
@@ -798,7 +823,7 @@ def header_data_to_xml(rows, cols, dtypes, col_bounds, col_to_format, df, dim):
         xml += '<colheader index=\"%s\" label=\"%s\" type=\"%s\" format=\"%s\" max=\"%s\" min=\"%s\" />\n' % \
                (str(col), col_label, dtypes[col], col_to_format(dtypes[col]), quote(str(col_format % bounds[1])), quote(str(col_format % bounds[0])))
     for row in range(rows):
-        xml += "<rowheader index=\"%s\" label = \"%s\"/>\n" % (str(row), quote(get_label(df.axes[0][row])))
+        xml += "<rowheader index=\"%s\" label = \"%s\"/>\n" % (str(row), quote(get_label(df.axes[0][row] if dim != -1 else str(row))))
     xml += "</headerdata>\n"
     return xml
 
@@ -820,7 +845,8 @@ TYPE_TO_XML_CONVERTERS = {
     "EagerTensor": tensor_to_xml,
     "ResourceVariable": tensor_to_xml,
     "SparseTensor": sparse_tensor_to_xml,
-    "Tensor": tensor_to_xml
+    "Tensor": tensor_to_xml,
+    "Dataset": dataset_to_xml
 }
 
 

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/_pydevd_bundle/pydevd_xml.py

@@ -11,14 +11,18 @@ from _pydev_bundle import pydev_log
 from _pydev_bundle.pydev_imports import quote
 from _pydevd_bundle import pydevd_extension_utils
 from _pydevd_bundle import pydevd_resolver
-from _pydevd_bundle.pydevd_constants import dict_iter_items, dict_keys, IS_PY3K, \
-    MAXIMUM_VARIABLE_REPRESENTATION_SIZE, RETURN_VALUES_DICT, LOAD_VALUES_POLICY, DEFAULT_VALUES_DICT, \
-    GET_FRAME_RETURN_GROUP
-from _pydevd_bundle.pydevd_extension_api import TypeResolveProvider, StrPresentationProvider
-from _pydevd_bundle.pydevd_user_type_renderers_utils import try_get_type_renderer_for_var
-from _pydevd_bundle.pydevd_utils import is_string, should_evaluate_full_value, should_evaluate_shape
-from _pydevd_bundle.pydevd_frame_type_handler import get_vars_handler, DO_NOT_PROCESS_VARS, XML_COMMUNICATION_VARS_HANDLER
+from _pydevd_bundle.pydevd_constants import dict_keys, IS_PY3K, \
+    LOAD_VALUES_POLICY, DEFAULT_VALUES_DICT
+from _pydevd_bundle.pydevd_extension_api import TypeResolveProvider, \
+    StrPresentationProvider
+from _pydevd_bundle.pydevd_frame_type_handler import get_vars_handler, \
+    DO_NOT_PROCESS_VARS, XML_COMMUNICATION_VARS_HANDLER
 from _pydevd_bundle.pydevd_repr_utils import get_value_repr
+from _pydevd_bundle.pydevd_user_type_renderers_utils import \
+    try_get_type_renderer_for_var
+from _pydevd_bundle.pydevd_utils import is_string, should_evaluate_full_value, \
+    should_evaluate_shape, is_safe_to_access
+
 try:
     import types
 
@@ -340,7 +344,7 @@ def var_to_xml(val, name, do_trim=True, additional_in_xml='', evaluate_full_valu
     # shape to xml
     xml_shape = ''
     try:
-        if should_evaluate_shape():
+        if should_evaluate_shape() and is_safe_to_access(v, 'shape'):
             if hasattr(v, 'shape') and not callable(v.shape):
                 xml_shape = ' shape="%s"' % make_valid_xml_value(str(tuple(v.shape)))
             elif hasattr(v, '__len__') and not is_string(v):

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/pydev_ipython/matplotlibtools.py

@@ -56,13 +56,26 @@ def find_gui_and_backend():
 def is_interactive_backend(backend):
     """ Check if backend is interactive """
     matplotlib = sys.modules['matplotlib']
-    from matplotlib.rcsetup import interactive_bk, non_interactive_bk  # @UnresolvedImport
-    if backend in interactive_bk:
-        return True
-    elif backend in non_interactive_bk:
-        return False
+    required_version = (3, 9)
+    installed_version = tuple(map(int, matplotlib.__version__.split(".")))
+
+    if installed_version >= required_version:
+        interactive_bk = matplotlib.backends.backend_registry.list_builtin(matplotlib.backends.BackendFilter.INTERACTIVE)
+        non_interactive_bk = matplotlib.backends.backend_registry.list_builtin(matplotlib.backends.BackendFilter.NON_INTERACTIVE)
+        if backend in interactive_bk:
+            return True
+        elif backend in non_interactive_bk:
+            return False
+        else:
+            return matplotlib.is_interactive()
     else:
-        return matplotlib.is_interactive()
+        from matplotlib.rcsetup import interactive_bk, non_interactive_bk  # @UnresolvedImport
+        if backend in interactive_bk:
+            return True
+        elif backend in non_interactive_bk:
+            return False
+        else:
+            return matplotlib.is_interactive()
 
 
 def patch_use(enable_gui_function):

{pydevd-pycharm-242.18071.12 → pydevd-pycharm-242.20224.89}/pydevd.py

@@ -59,7 +59,8 @@ from _pydevd_bundle.pydevd_kill_all_pydevd_threads import kill_all_pydev_threads
 from _pydevd_bundle.pydevd_trace_dispatch import (
     trace_dispatch as _trace_dispatch, global_cache_skips, global_cache_frame_skips, show_tracing_warning)
 from _pydevd_frame_eval.pydevd_frame_eval_main import (
-    frame_eval_func, dummy_trace_dispatch, show_frame_eval_warning)
+    frame_eval_func, clear_thread_local_info, dummy_trace_dispatch,
+    show_frame_eval_warning)
 from _pydevd_bundle.pydevd_pep_669_tracing_wrapper import enable_pep669_monitoring
 from _pydevd_bundle.pydevd_additional_thread_info import set_additional_thread_info
 from _pydevd_bundle.pydevd_utils import save_main_module, is_current_thread_main_thread, \
@@ -385,8 +386,13 @@ def stoptrace():
 
             kill_all_pydev_threads()
 
+            set_global_debugger(None)
+
         connected = False
 
+    if clear_thread_local_info is not None:
+        clear_thread_local_info()
+
 
 #=======================================================================================================================
 # PyDB
@@ -1953,7 +1959,6 @@ def settrace_forked():
     from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder
     GlobalDebuggerHolder.global_dbg = None
 
-    from _pydevd_frame_eval.pydevd_frame_eval_main import clear_thread_local_info
     host, port = dispatch()
 
     import pydevd_tracing