pydevd-pycharm 252.26199.168__tar.gz → 253.20558.58__tar.gz

{pydevd_pycharm-252.26199.168/pydevd_pycharm.egg-info → pydevd_pycharm-253.20558.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pydevd-pycharm
-Version: 252.26199.168
+Version: 253.20558.58
 Summary: PyCharm Debugger (used in PyCharm and PyDev)
 Home-page: https://github.com/JetBrains/intellij-community
 Author: JetBrains, Fabio Zadrozny and others
@@ -50,7 +50,7 @@ any other variant which properly supports the Python structure for debuggers --
 
 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.
+`build_tools/build.py` should be run -- note that the resulting .pyx and .c files should be committed.
 
 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).

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/README.md

@@ -19,7 +19,7 @@ any other variant which properly supports the Python structure for debuggers --
 
 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.
+`build_tools/build.py` should be run -- note that the resulting .pyx and .c files should be committed.
 
 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).

pydevd_pycharm-253.20558.58/VERSION

@@ -0,0 +1 @@
+253.20558.58

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydev_bundle/pydev_console_utils.py

@@ -13,6 +13,7 @@ from _pydevd_bundle.pydevd_comm import InternalDataViewerAction
 from _pydevd_bundle.pydevd_constants import IS_JYTHON, dict_iter_items
 from _pydevd_bundle.pydevd_tables import exec_table_command
 from _pydevd_bundle.pydevd_tables import exec_image_table_command
+from _pydevd_bundle.pydevd_tables import exec_raw
 from _pydevd_bundle.pydevd_user_type_renderers import parse_set_type_renderers_message
 from pydev_console.pydev_protocol import CompletionOption, CompletionOptionType, \
     PythonUnhandledException, PythonTableException
@@ -432,6 +433,17 @@ class BaseInterpreterInterface(BaseCodeExecutor):
         if not success:
             raise PythonTableException(str(res))
 
+    #
+    def execRaw(self, command):
+        try:
+            success, res = exec_raw(command, self.get_namespace(), self.get_namespace())
+            if success:
+                return res
+        except:
+            traceback.print_exc()
+            raise PythonUnhandledException(traceback.format_exc())
+        if not success:
+            raise PythonUnhandledException(str(res))
 
     #
     def execTableImageCommand(self, command, command_type, offset, image_id):

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydev_bundle/pydev_monkey.py

@@ -462,6 +462,8 @@ def create_warn_multiproc(original_name):
 
     return new_warn_multiproc
 
+def patch_path(path, args):
+    return args[0] if is_python(path) and args[0] == sys.executable else path
 
 def create_execl(original_name):
     def new_execl(path, *args):
@@ -474,6 +476,7 @@ def create_execl(original_name):
         import os
         args = patch_args(args)
         if is_python_args(args):
+            path = patch_path(path, args)
             send_process_will_be_substituted()
         return getattr(os, original_name)(path, *args)
     return new_execl
@@ -488,6 +491,7 @@ def create_execv(original_name):
         import os
         args = patch_args(args)
         if is_python_args(args):
+            path = patch_path(path, args)
             send_process_will_be_substituted()
         return getattr(os, original_name)(path, args)
     return new_execv
@@ -502,6 +506,7 @@ def create_execve(original_name):
         import os
         args = patch_args(args)
         if is_python_args(args):
+            path = patch_path(path, args)
             send_process_will_be_substituted()
         return getattr(os, original_name)(path, args, env)
     return new_execve

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/pydevd_comm.py

@@ -151,7 +151,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 = "252.26199.168"
+VERSION_STRING = "253.20558.58"
 
 from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
 file_system_encoding = getfilesystemencoding()

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/pydevd_console_output.py

@@ -9,11 +9,11 @@ class ConsoleOutputHook:
         self.original_out = out
         self.is_error = is_stderr
 
-    def write(self, str):
-        if len(str) > MAX_STRING_LENGTH:
-            self._write_long_string(str)
+    def write(self, string):
+        if len(string) > MAX_STRING_LENGTH:
+            self._write_long_string(string)
         else:
-            self._write_short_string(str)
+            self._write_short_string(string)
 
     def flush(self):
         pass
@@ -24,15 +24,15 @@ class ConsoleOutputHook:
             return getattr(self.original_out, item)
         raise AttributeError("%s has no attribute %s" % (self.original_out, item))
 
-    def _write_long_string(self, str):
-        str_len, chunk_size = len(str), len(str) // MAX_STRING_LENGTH
+    def _write_long_string(self, string):
+        str_len, chunk_size = len(string), len(string) // MAX_STRING_LENGTH
         for i in range(0, str_len, chunk_size):
-            self._write_short_string(str[i:i + chunk_size])
+            self._write_short_string(string[i:i + chunk_size])
 
-    def _write_short_string(self, str):
+    def _write_short_string(self, string):
         if self.is_error:
-            cmd = self.dbg.cmd_factory.make_io_message(str, WRITE_ERR)
+            cmd = self.dbg.cmd_factory.make_io_message(string, WRITE_ERR)
         else:
-            cmd = self.dbg.cmd_factory.make_io_message(str, WRITE_OUT)
+            cmd = self.dbg.cmd_factory.make_io_message(string, WRITE_OUT)
 
         self.dbg.writer.add_command(cmd)

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/pydevd_dont_trace_files.py

@@ -108,7 +108,6 @@ DONT_TRACE = {
     'pydevd_import_class.py': PYDEV_FILE,
     'pydevd_io.py': PYDEV_FILE,
     'pydevd_ipython_console_output.py': PYDEV_FILE,
-    'pydevd_kill_all_pydevd_threads.py': PYDEV_FILE,
     'pydevd_matplotlib_image.py': PYDEV_FILE,
     'pydevd_modify_bytecode.py': PYDEV_FILE,
     'pydevd_numpy.py': PYDEV_FILE,

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/pydevd_tables.py

@@ -5,7 +5,7 @@ from _pydevd_bundle import pydevd_vars
 from _pydevd_bundle.pydevd_constants import NEXT_VALUE_SEPARATOR
 from _pydevd_bundle.pydevd_xml import ExceptionOnEvaluate
 from _pydevd_bundle.tables.images.pydevd_image_loader import load_image_chunk
-
+from _pydev_bundle.pydev_imports import Exec
 
 class TableCommandType:
     DF_INFO = "DF_INFO"
@@ -42,6 +42,13 @@ def exec_image_table_command(init_command, command_type, offset, image_id, f_glo
     return True, load_image_chunk(offset, image_id)
 
 
+def exec_raw(command, f_globals, f_locals):
+    try:
+        res = Exec(command, f_globals, f_locals)
+        return True, str(res)
+    except:
+        return False, pydevd_vars.get_eval_exception_msg(command, f_locals).result
+
 def exec_table_command(init_command, command_type, start_index, end_index, format, f_globals,
                        f_locals):
     table = pydevd_vars.eval_in_context(init_command, f_globals, f_locals)

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/pydevd_thrift.py

@@ -345,9 +345,7 @@ def var_to_struct(val, name, format='%s', do_trim=True, evaluate_full_value=True
     # data type info to xml (for arrays and tensors)
     debug_value.arrayElementType = ''
     try:
-        if (is_container_with_shape_dtype(type_qualifier, typeName, v)
-                and hasattr(v, 'dtype')
-                and hasattr(v.dtype, 'name')):
+        if is_container_with_shape_dtype(type_qualifier, typeName, v) and hasattr(v, 'dtype'):
             debug_value.arrayElementType = str(v.dtype)
     except:
         pass

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/pydevd_user_type_renderers_utils.py

@@ -1,8 +1,41 @@
 #  Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 import inspect
-
 from _pydevd_bundle import pydevd_utils
 
+try:
+    # IDE's own module importer (handles namespace packages, zip, etc.)
+    from _pydevd_bundle import pydevd_import_class as _pydevd_import_class
+except Exception:
+    _pydevd_import_class = None
+
+def _resolve_type(path):
+    """Resolve 'pkg.mod.Class' -> class object, or None."""
+    if not path:
+        return None
+    # Prefer pydevd's own importer so future understandings
+    # over runtime module imports may propagate seamlessly
+    if _pydevd_import_class is not None:
+        for attr in ('import_name', 'ImportName'):
+            fn = getattr(_pydevd_import_class, attr, None)
+            if callable(fn):
+                try:
+                    return fn(path)
+                except:
+                    pass
+    return None
+
+def _by_type_entities(cls, renderers_dict):
+    """Resolve names into types for entity-bound type matching criteria"""
+    for render in [render for renders in renderers_dict.values() for render in renders]:
+        try:
+            for name_type in ('type_canonical_import_path','type_qualified_name'):
+                target = _resolve_type(getattr(render, name_type, None))
+                if cls is target:
+                    return render
+        except:
+            pass
+    return None
+
 
 class TypeRenderersConstants:
     new_line = "@_@NEW_LINE_CHAR@_@"
@@ -15,7 +48,8 @@ def try_get_type_renderer_for_var(var, renderers_dict):
         cls_name = cls.__name__
         renderers_for_name = renderers_dict.get(cls_name)
         if renderers_for_name is None:
-            return None
+            # by class type entities
+            return _by_type_entities(cls, renderers_dict)
 
         module_name = cls.__module__
         qualified_name = module_name + "." + cls_name
@@ -37,12 +71,8 @@ def try_get_type_renderer_for_var(var, renderers_dict):
             for render in renderers_for_name:
                 if render.type_src_file == src_file:
                     return render
-            return None
-
-        # by qualified name
-        for render in renderers_for_name:
-            if render.type_qualified_name == qualified_name:
-                return render
+            # by class type entities
+            return _by_type_entities(cls, renderers_dict)
 
         # by module root and class name
         # (if module contains only one class with the same name)
@@ -52,6 +82,10 @@ def try_get_type_renderer_for_var(var, renderers_dict):
                 renderer_module_root = render.type_canonical_import_path.split(".")[0]
                 if renderer_module_root == module_root:
                     return render
+
+        # by qualified name
+        return _by_type_entities(cls, renderers_dict)
+
     except:
         pass
 

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/pydevd_utils.py

@@ -7,12 +7,12 @@ import traceback
 
 try:
     import torch
-except ImportError:
+except Exception:
     pass
 
 try:
     import tensorflow as tf
-except ImportError:
+except Exception:
     pass
 
 import pydevd_file_utils

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/pydevd_xml.py

@@ -356,9 +356,8 @@ def var_to_xml(val, name, do_trim=True, additional_in_xml='', evaluate_full_valu
     # we use it for view as image
     xml_data_type = ''
     try:
-        if (is_container_with_shape_dtype(type_qualifier, typeName, v)
-                and hasattr(v.dtype, 'name')):
-            xml_data_type = ' arrayElementType="%s"' % make_valid_xml_value(v.dtype.name)
+        if is_container_with_shape_dtype(type_qualifier, typeName, v):
+            xml_data_type = ' arrayElementType="%s"' % make_valid_xml_value(str(v.dtype))
     except:
         pass
 

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/tables/images/pydevd_numpy_image.py

@@ -3,6 +3,7 @@ import numpy as np
 from _pydevd_bundle.tables.images.pydevd_image_loader import (save_image_to_storage, GRAYSCALE_MODE, RGB_MODE, RGBA_MODE)
 
 MAX_PIXELS = 144_000_000
+MAX_DIMENSION = 15_000
 
 def create_image(arr):
     # type: (np.ndarray) -> str
@@ -26,10 +27,14 @@ def create_image(arr):
         h, w = arr_to_convert.shape[:2]
         channels = arr_to_convert.shape[2] if arr_to_convert.ndim == 3 else 1
         total_pixels = h * w * channels
-        if total_pixels > MAX_PIXELS:
-            scale = (MAX_PIXELS / total_pixels) ** 0.5
-            new_h, new_w = max(1, int(h * scale)), max(1, int(w * scale))
-            arr_to_convert = average_pooling(arr_to_convert, new_h, new_w)
+        if (total_pixels > MAX_PIXELS) or (h > MAX_DIMENSION) or (w > MAX_DIMENSION):
+            scale_h = min(1.0, MAX_DIMENSION / float(h))
+            scale_w = min(1.0, MAX_DIMENSION / float(w))
+            scale_p = (MAX_PIXELS / float(total_pixels)) ** 0.5 if total_pixels > MAX_PIXELS else 1.0
+            scale = min(scale_h, scale_w, scale_p)
+            new_h, new_w = max(1, int(round(h * scale))), max(1, int(round(w * scale)))
+            if new_h < h or new_w < w:
+                arr_to_convert = average_pooling(arr_to_convert, new_h, new_w)
 
         arr_min, arr_max = arr_to_convert.min(), arr_to_convert.max()
         is_float = np.issubdtype(arr_to_convert.dtype, np.floating)

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/_pydevd_bundle/tables/pydevd_pandas.py

@@ -17,6 +17,25 @@ UNSUPPORTED_KINDS = {"c", "V"}  # complex, void/raw
 OBJECT_SAMPLE_LIMIT = 10
 
 
+class InspectionResultsDict:
+    KEY_INSPECTION_NAME = "inspection"
+
+    KEY_STATUS = "executionStatus"
+    VALUE_STATUS_SUCCESS = "SUCCESS"
+    VALUE_STATUS_FAILED = "FAILED"
+
+    KEY_IS_TRIGGERED = "isTriggered"
+    VALUE_TRIGGERED_NO = "NO"
+    VALUE_TRIGGERED_YES = "YES"
+
+    KEY_DETAILS = "inspectionResultDetails"
+    KEY_DETAILS_TYPE = "type"
+    VALUE_DETAILS_TYPE_ALL = "All"
+    VALUE_DETAILS_TYPE_PER_COLUMN = "PerColumn"
+
+    KEY_DETAILS_VALUE = "value"
+
+
 class ColumnVisualisationType:
     HISTOGRAM = "histogram"
     UNIQUE = "unique"
@@ -124,6 +143,79 @@ def get_value_occurrences_count(table):
     return ColumnVisualisationUtils.TABLE_OCCURRENCES_COUNT_NEXT_COLUMN_SEPARATOR.join(bin_counts)
 
 
+def get_inspection_none_count(table):
+    def _calculate_none_count(cur_table):
+        """Calculate missing values per column"""
+        results_per_column = []
+        for col, missing_count in cur_table.isna().sum().items():
+            if missing_count > 0:
+                results_per_column.append({
+                    "columnName": col,
+                    "value": str(missing_count)
+                })
+
+        is_triggered = len(results_per_column) > 0
+        details = __create_per_column_details(results_per_column) if is_triggered else None
+        return __create_success_result(is_triggered, details)
+
+    return __execute_inspection(table, _calculate_none_count, "NONE_COUNT")
+
+
+def get_inspection_duplicate_rows(table):
+    def _calculate_duplicate_rows(cur_table):
+        duplicate_rows_number = cur_table.duplicated().sum()
+        is_triggered = duplicate_rows_number > 0
+        details = __create_all_details(str(duplicate_rows_number)) if is_triggered else None
+        return __create_success_result(is_triggered, details)
+
+    return __execute_inspection(table, _calculate_duplicate_rows, "DUPLICATE_ROWS")
+
+
+def get_inspection_outliers(table):
+    def _calculate_outliers(cur_table):
+        results_per_column = []
+        for col in cur_table.columns:
+            if pd.api.types.is_numeric_dtype(cur_table[col]):
+                q1 = cur_table[col].quantile(0.25)
+                q3 = cur_table[col].quantile(0.75)
+                iqr = q3 - q1
+                lower_bound = q1 - 1.5 * iqr
+                upper_bound = q3 + 1.5 * iqr
+
+                # Boolean mask for outliers
+                mask = (cur_table[col] < lower_bound) | (cur_table[col] > upper_bound)
+                outliers_count = cur_table[col][mask].count()
+
+                if outliers_count > 0:
+                    results_per_column.append({
+                        "columnName": col,
+                        "value": str(outliers_count)
+                    })
+
+        is_triggered = len(results_per_column) > 0
+        details = __create_per_column_details(results_per_column) if is_triggered else None
+        return __create_success_result(is_triggered, details)
+
+    return __execute_inspection(table, _calculate_outliers, "OUTLIERS")
+
+
+def get_inspection_constant_columns(table):
+    def _calculate_constant_columns(cur_table):
+        results_per_column = []
+        for col in cur_table.columns:
+            if cur_table[col].nunique(dropna=False) == 1:
+                results_per_column.append({
+                    "columnName": col,
+                    "value": str(cur_table[col].iloc[0])
+                })
+
+        is_triggered = len(results_per_column) > 0
+        details = __create_per_column_details(results_per_column) if is_triggered else None
+        return __create_success_result(is_triggered, details)
+
+    return __execute_inspection(table, _calculate_constant_columns, "CONSTANT_COLUMNS")
+
+
 def __get_data_slice(table, start, end):
     return __convert_to_df(table).iloc[start:end]
 
@@ -376,3 +468,53 @@ def __get_describe(table):
                 return __get_dummy_describe_series(table)
     except:
         return None
+
+
+def __serialize_in_json(result_in_dict, inspection_name):
+    try:
+        import json
+        result_in_dict[InspectionResultsDict.KEY_INSPECTION_NAME] = inspection_name
+        return json.dumps(result_in_dict)
+    except:
+        return '{"%s": "%s" "%s": "%s"}' % (InspectionResultsDict.KEY_INSPECTION_NAME, inspection_name, InspectionResultsDict.KEY_STATUS, InspectionResultsDict.VALUE_STATUS_FAILED)
+
+
+def __execute_inspection(table, inspection_func, inspection_name):
+    """Execute inspection with error handling"""
+    try:
+        result = inspection_func(table)
+        return __serialize_in_json(result, inspection_name)
+    except:
+        failed_result = __create_failed_result()
+        return __serialize_in_json(failed_result, inspection_name)
+
+
+def __create_success_result(is_triggered, details=None):
+     is_triggered_value = InspectionResultsDict.VALUE_TRIGGERED_YES if is_triggered else InspectionResultsDict.VALUE_TRIGGERED_NO
+     result = {
+         InspectionResultsDict.KEY_STATUS: InspectionResultsDict.VALUE_STATUS_SUCCESS,
+         InspectionResultsDict.KEY_IS_TRIGGERED: is_triggered_value
+     }
+     if details:
+         result[InspectionResultsDict.KEY_DETAILS] = details
+     return result
+
+
+def __create_failed_result():
+    return {
+        InspectionResultsDict.KEY_STATUS: InspectionResultsDict.VALUE_STATUS_FAILED,
+        InspectionResultsDict.KEY_IS_TRIGGERED: InspectionResultsDict.VALUE_TRIGGERED_NO
+    }
+
+
+def __create_per_column_details(results_per_column):
+    return {
+        InspectionResultsDict.KEY_DETAILS_TYPE: InspectionResultsDict.VALUE_DETAILS_TYPE_PER_COLUMN,
+        InspectionResultsDict.KEY_DETAILS_VALUE: results_per_column
+    }
+
+def __create_all_details(value):
+    return {
+        InspectionResultsDict.KEY_DETAILS_TYPE: InspectionResultsDict.VALUE_DETAILS_TYPE_ALL,
+        InspectionResultsDict.KEY_DETAILS_VALUE: value
+    }

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/pydev_ipython/inputhook.py

@@ -27,6 +27,7 @@ GUI_QT = 'qt'
 GUI_QT4 = 'qt4'
 GUI_QT5 = 'qt5'
 GUI_QT6 = 'qt6'
+GUI_PYSIDE = 'pyside'
 GUI_GTK = 'gtk'
 GUI_TK = 'tk'
 GUI_OSX = 'osx'
@@ -180,9 +181,11 @@ class InputHookManager(object):
         self.clear_inputhook()
 
     def enable_qt(self, app=None):
-        from pydev_ipython.qt_for_kernel import QT_API, QT_API_PYQT5, QT_API_PYQT6
+        from pydev_ipython.qt_for_kernel import QT_API, QT_API_PYQT5, QT_API_PYQT6, QT_API_PYSIDE
         if QT_API == QT_API_PYQT6:
             self.enable_qt6(app)
+        elif QT_API == QT_API_PYSIDE:
+            self.enable_pyside(app)
         elif QT_API == QT_API_PYQT5:
             self.enable_qt5(app)
         else:
@@ -245,7 +248,7 @@ class InputHookManager(object):
 
     def enable_qt6(self, app=None):
         from pydev_ipython.inputhookqt6 import create_inputhook_qt6
-        app, inputhook_qt6 = create_inputhook_qt6(self, app)
+        app, inputhook_qt6 = create_inputhook_qt6(self, app, GUI_QT6)
         self.set_inputhook(inputhook_qt6)
 
         self._current_gui = GUI_QT6
@@ -253,6 +256,16 @@ class InputHookManager(object):
         self._apps[GUI_QT6] = app
         return app
 
+    def enable_pyside(self, app=None):
+        from pydev_ipython.inputhookqt6 import create_inputhook_qt6
+        app, inputhook_pyside = create_inputhook_qt6(self, app, GUI_PYSIDE)
+        self.set_inputhook(inputhook_pyside)
+
+        self._current_gui = GUI_PYSIDE
+        app._in_event_loop = True
+        self._apps[GUI_PYSIDE] = app
+        return app
+
     def disable_qt6(self):
         if GUI_QT6 in self._apps:
             self._apps[GUI_QT6]._in_event_loop = False

{pydevd_pycharm-252.26199.168 → pydevd_pycharm-253.20558.58}/pydev_ipython/inputhookqt6.py

@@ -22,8 +22,7 @@ import signal
 import threading
 
 
-from PyQt6 import QtCore, QtGui
-from pydev_ipython.inputhook import allow_CTRL_C, ignore_CTRL_C, stdin_ready
+from pydev_ipython.inputhook import allow_CTRL_C, ignore_CTRL_C, stdin_ready, GUI_QT6, GUI_PYSIDE
 
 # To minimise future merging complexity, rather than edit the entire code base below
 # we fake InteractiveShell here
@@ -51,7 +50,7 @@ sigint_timer = None
 # Code
 #-----------------------------------------------------------------------------
 
-def create_inputhook_qt6(mgr, app=None):
+def create_inputhook_qt6(mgr, app=None, gui=GUI_QT6):
     """Create an input hook for running the Qt6 application event loop.
 
     Parameters
@@ -79,10 +78,18 @@ def create_inputhook_qt6(mgr, app=None):
     """
 
     if app is None:
-        app = QtCore.QCoreApplication.instance()
-        if app is None:
-            from PyQt6 import QtWidgets
-            app = QtWidgets.QApplication([" "])
+        if gui == GUI_QT6:
+            from PyQt6 import QtCore
+            app = QtCore.QCoreApplication.instance()
+            if app is None:
+                from PyQt6 import QtWidgets
+                app = QtWidgets.QApplication([" "])
+        elif gui == GUI_PYSIDE:
+            from PySide6 import QtCore
+            app = QtCore.QCoreApplication.instance()
+            if app is None:
+                from PySide6 import QtWidgets
+                app = QtWidgets.QApplication([" "])
 
     # Re-use previously created inputhook if any
     ip = InteractiveShell.instance()