debugpy 1.8.5__zip → 1.8.7__zip

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookpyglet.py

@@ -9,16 +9,16 @@ Authors
 * Fernando Perez
 """
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import os
 import sys
@@ -32,19 +32,22 @@ from pydev_ipython.inputhook import stdin_ready
 # window close.  For details, see:
 # http://groups.google.com/group/pyglet-users/browse_thread/thread/47c1aab9aa4a3d23/c22f9e819826799e?#c22f9e819826799e
 
-if sys.platform.startswith('linux'):
+if sys.platform.startswith("linux"):
+
     def flip(window):
         try:
             window.flip()
         except AttributeError:
             pass
 else:
+
     def flip(window):
         window.flip()
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
 
 def inputhook_pyglet():
     """Run the pyglet event loop by processing pending events only.
@@ -63,7 +66,7 @@ def inputhook_pyglet():
             for window in pyglet.app.windows:
                 window.switch_to()
                 window.dispatch_events()
-                window.dispatch_event('on_draw')
+                window.dispatch_event("on_draw")
                 flip(window)
 
             # We need to sleep at this point to keep the idle CPU load

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookqt4.py

@@ -5,16 +5,16 @@ Qt4's inputhook support function
 Author: Christian Boos
 """
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import os
 import signal
@@ -25,31 +25,35 @@ import threading
 from pydev_ipython.qt_for_kernel import QtCore, QtGui
 from pydev_ipython.inputhook import allow_CTRL_C, ignore_CTRL_C, stdin_ready
 
+
 # To minimise future merging complexity, rather than edit the entire code base below
 # we fake InteractiveShell here
 class InteractiveShell:
     _instance = None
+
     @classmethod
     def instance(cls):
         if cls._instance is None:
             cls._instance = cls()
         return cls._instance
+
     def set_hook(self, *args, **kwargs):
         # We don't consider the pre_prompt_hook because we don't have
         # KeyboardInterrupts to consider since we are running under PyDev
         pass
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Module Globals
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 got_kbdint = False
 sigint_timer = None
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
 
 def create_inputhook_qt4(mgr, app=None):
     """Create an input hook for running the Qt4 application event loop.
@@ -85,7 +89,7 @@ def create_inputhook_qt4(mgr, app=None):
 
     # Re-use previously created inputhook if any
     ip = InteractiveShell.instance()
-    if hasattr(ip, '_inputhook_qt4'):
+    if hasattr(ip, "_inputhook_qt4"):
         return app, ip._inputhook_qt4
 
     # Otherwise create the inputhook_qt4/preprompthook_qt4 pair of
@@ -106,7 +110,7 @@ def create_inputhook_qt4(mgr, app=None):
         try:
             allow_CTRL_C()
             app = QtCore.QCoreApplication.instance()
-            if not app: # shouldn't happen, but safer if it happens anyway...
+            if not app:  # shouldn't happen, but safer if it happens anyway...
                 return 0
             app.processEvents(QtCore.QEventLoop.AllEvents, 300)
             if not stdin_ready():
@@ -154,19 +158,18 @@ def create_inputhook_qt4(mgr, app=None):
             #
             # Unfortunately this doesn't work on Windows (SIGINT kills
             # Python and CTRL_C_EVENT doesn't work).
-            if(os.name == 'posix'):
+            if os.name == "posix":
                 pid = os.getpid()
-                if(not sigint_timer):
-                    sigint_timer = threading.Timer(.01, os.kill,
-                                         args=[pid, signal.SIGINT] )
+                if not sigint_timer:
+                    sigint_timer = threading.Timer(0.01, os.kill, args=[pid, signal.SIGINT])
                     sigint_timer.start()
             else:
                 print("\nKeyboardInterrupt - Ctrl-C again for new prompt")
 
-
-        except: # NO exceptions are allowed to escape from a ctypes callback
+        except:  # NO exceptions are allowed to escape from a ctypes callback
             ignore_CTRL_C()
             from traceback import print_exc
+
             print_exc()
             print("Got exception from inputhook_qt4, unregistering.")
             mgr.clear_inputhook()
@@ -182,7 +185,7 @@ def create_inputhook_qt4(mgr, app=None):
         """
         global got_kbdint, sigint_timer
 
-        if(sigint_timer):
+        if sigint_timer:
             sigint_timer.cancel()
             sigint_timer = None
 
@@ -191,6 +194,6 @@ def create_inputhook_qt4(mgr, app=None):
         got_kbdint = False
 
     ip._inputhook_qt4 = inputhook_qt4
-    ip.set_hook('pre_prompt_hook', preprompthook_qt4)
+    ip.set_hook("pre_prompt_hook", preprompthook_qt4)
 
     return app, inputhook_qt4

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookqt5.py

@@ -5,16 +5,16 @@ Qt5's inputhook support function
 Author: Christian Boos
 """
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import os
 import signal
@@ -41,17 +41,18 @@ class InteractiveShell:
         # KeyboardInterrupts to consider since we are running under PyDev
         pass
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 # Module Globals
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 got_kbdint = False
 sigint_timer = None
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 def create_inputhook_qt5(mgr, app=None):
@@ -85,11 +86,12 @@ def create_inputhook_qt5(mgr, app=None):
         app = QtCore.QCoreApplication.instance()
         if app is None:
             from PyQt5 import QtWidgets
+
             app = QtWidgets.QApplication([" "])
 
     # Re-use previously created inputhook if any
     ip = InteractiveShell.instance()
-    if hasattr(ip, '_inputhook_qt5'):
+    if hasattr(ip, "_inputhook_qt5"):
         return app, ip._inputhook_qt5
 
     # Otherwise create the inputhook_qt5/preprompthook_qt5 pair of
@@ -158,11 +160,10 @@ def create_inputhook_qt5(mgr, app=None):
             #
             # Unfortunately this doesn't work on Windows (SIGINT kills
             # Python and CTRL_C_EVENT doesn't work).
-            if(os.name == 'posix'):
+            if os.name == "posix":
                 pid = os.getpid()
-                if(not sigint_timer):
-                    sigint_timer = threading.Timer(.01, os.kill,
-                                         args=[pid, signal.SIGINT])
+                if not sigint_timer:
+                    sigint_timer = threading.Timer(0.01, os.kill, args=[pid, signal.SIGINT])
                     sigint_timer.start()
             else:
                 print("\nKeyboardInterrupt - Ctrl-C again for new prompt")
@@ -170,6 +171,7 @@ def create_inputhook_qt5(mgr, app=None):
         except:  # NO exceptions are allowed to escape from a ctypes callback
             ignore_CTRL_C()
             from traceback import print_exc
+
             print_exc()
             print("Got exception from inputhook_qt5, unregistering.")
             mgr.clear_inputhook()
@@ -185,7 +187,7 @@ def create_inputhook_qt5(mgr, app=None):
         """
         global got_kbdint, sigint_timer
 
-        if(sigint_timer):
+        if sigint_timer:
             sigint_timer.cancel()
             sigint_timer = None
 
@@ -194,6 +196,6 @@ def create_inputhook_qt5(mgr, app=None):
         got_kbdint = False
 
     ip._inputhook_qt5 = inputhook_qt5
-    ip.set_hook('pre_prompt_hook', preprompthook_qt5)
+    ip.set_hook("pre_prompt_hook", preprompthook_qt5)
 
     return app, inputhook_qt5

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookqt6.py

@@ -5,16 +5,16 @@ Qt6's inputhook support function
 Author: Christian Boos, Marijn van Vliet
 """
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import os
 import signal
@@ -41,17 +41,18 @@ class InteractiveShell:
         # KeyboardInterrupts to consider since we are running under PyDev
         pass
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 # Module Globals
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 got_kbdint = False
 sigint_timer = None
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 def create_inputhook_qt6(mgr, app=None):
@@ -85,11 +86,12 @@ def create_inputhook_qt6(mgr, app=None):
         app = QtCore.QCoreApplication.instance()
         if app is None:
             from PyQt6 import QtWidgets
+
             app = QtWidgets.QApplication([" "])
 
     # Re-use previously created inputhook if any
     ip = InteractiveShell.instance()
-    if hasattr(ip, '_inputhook_qt6'):
+    if hasattr(ip, "_inputhook_qt6"):
         return app, ip._inputhook_qt6
 
     # Otherwise create the inputhook_qt6/preprompthook_qt6 pair of
@@ -158,11 +160,10 @@ def create_inputhook_qt6(mgr, app=None):
             #
             # Unfortunately this doesn't work on Windows (SIGINT kills
             # Python and CTRL_C_EVENT doesn't work).
-            if(os.name == 'posix'):
+            if os.name == "posix":
                 pid = os.getpid()
-                if(not sigint_timer):
-                    sigint_timer = threading.Timer(.01, os.kill,
-                                         args=[pid, signal.SIGINT])
+                if not sigint_timer:
+                    sigint_timer = threading.Timer(0.01, os.kill, args=[pid, signal.SIGINT])
                     sigint_timer.start()
             else:
                 print("\nKeyboardInterrupt - Ctrl-C again for new prompt")
@@ -170,6 +171,7 @@ def create_inputhook_qt6(mgr, app=None):
         except:  # NO exceptions are allowed to escape from a ctypes callback
             ignore_CTRL_C()
             from traceback import print_exc
+
             print_exc()
             print("Got exception from inputhook_qt6, unregistering.")
             mgr.clear_inputhook()
@@ -185,7 +187,7 @@ def create_inputhook_qt6(mgr, app=None):
         """
         global got_kbdint, sigint_timer
 
-        if(sigint_timer):
+        if sigint_timer:
             sigint_timer.cancel()
             sigint_timer = None
 
@@ -194,6 +196,6 @@ def create_inputhook_qt6(mgr, app=None):
         got_kbdint = False
 
     ip._inputhook_qt6 = inputhook_qt6
-    ip.set_hook('pre_prompt_hook', preprompthook_qt6)
+    ip.set_hook("pre_prompt_hook", preprompthook_qt6)
 
     return app, inputhook_qt6

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhooktk.py

@@ -2,22 +2,24 @@
 # Unlike what IPython does, we need to have an explicit inputhook because tkinter handles
 # input hook in the C Source code
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 from pydev_ipython.inputhook import stdin_ready
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 TCL_DONT_WAIT = 1 << 1
 
+
 def create_inputhook_tk(app):
     def inputhook_tk():
         while app.dooneevent(TCL_DONT_WAIT) == 1:
             if stdin_ready():
                 break
         return 0
+
     return inputhook_tk

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/inputhookwx.py

@@ -5,16 +5,16 @@ Enable wxPython to be used interacive by setting PyOS_InputHook.
 Authors:  Robin Dunn, Brian Granger, Ondrej Certik
 """
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import sys
 import signal
@@ -25,9 +25,10 @@ import wx
 from pydev_ipython.inputhook import stdin_ready
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
 
 def inputhook_wx1():
     """Run the wx event loop by processing pending events only.
@@ -53,8 +54,8 @@ def inputhook_wx1():
         pass
     return 0
 
-class EventLoopTimer(wx.Timer):  # @UndefinedVariable
 
+class EventLoopTimer(wx.Timer):  # @UndefinedVariable
     def __init__(self, func):
         self.func = func
         wx.Timer.__init__(self)  # @UndefinedVariable
@@ -62,8 +63,8 @@ class EventLoopTimer(wx.Timer):  # @UndefinedVariable
     def Notify(self):
         self.func()
 
-class EventLoopRunner(object):
 
+class EventLoopRunner(object):
     def Run(self, time):
         self.evtloop = wx.EventLoop()  # @UndefinedVariable
         self.timer = EventLoopTimer(self.check_stdin)
@@ -75,6 +76,7 @@ class EventLoopRunner(object):
             self.timer.Stop()
             self.evtloop.Exit()
 
+
 def inputhook_wx2():
     """Run the wx event loop, polling for stdin.
 
@@ -101,6 +103,7 @@ def inputhook_wx2():
         pass
     return 0
 
+
 def inputhook_wx3():
     """Run the wx event loop by processing pending events only.
 
@@ -114,7 +117,7 @@ def inputhook_wx3():
     try:
         app = wx.GetApp()  # @UndefinedVariable
         if app is not None:
-            if hasattr(wx, 'IsMainThread'):
+            if hasattr(wx, "IsMainThread"):
                 assert wx.IsMainThread()  # @UndefinedVariable
             else:
                 assert wx.Thread_IsMain()  # @UndefinedVariable
@@ -159,7 +162,8 @@ def inputhook_wx3():
         pass
     return 0
 
-if sys.platform == 'darwin':
+
+if sys.platform == "darwin":
     # On OSX, evtloop.Pending() always returns True, regardless of there being
     # any events pending. As such we can't use implementations 1 or 3 of the
     # inputhook as those depend on a pending/dispatch loop.

{debugpy-1.8.5 → debugpy-1.8.7}/src/debugpy/_vendored/pydevd/pydev_ipython/matplotlibtools.py

@@ -1,15 +1,16 @@
-
 import sys
 from _pydev_bundle import pydev_log
 
-backends = {'tk': 'TkAgg',
-            'gtk': 'GTKAgg',
-            'wx': 'WXAgg',
-            'qt': 'QtAgg', # Auto-choose qt4/5
-            'qt4': 'Qt4Agg',
-            'qt5': 'Qt5Agg',
-            'qt6': 'Qt6Agg',
-            'osx': 'MacOSX'}
+backends = {
+    "tk": "TkAgg",
+    "gtk": "GTKAgg",
+    "wx": "WXAgg",
+    "qt": "QtAgg",  # Auto-choose qt4/5
+    "qt4": "Qt4Agg",
+    "qt5": "Qt5Agg",
+    "qt6": "Qt6Agg",
+    "osx": "MacOSX",
+}
 
 # We also need a reverse backends2guis mapping that will properly choose which
 # GUI support to activate based on the desired matplotlib backend.  For the
@@ -18,21 +19,23 @@ backends = {'tk': 'TkAgg',
 backend2gui = dict(zip(backends.values(), backends.keys()))
 # In the reverse mapping, there are a few extra valid matplotlib backends that
 # map to the same GUI support
-backend2gui['GTK'] = backend2gui['GTKCairo'] = 'gtk'
-backend2gui['WX'] = 'wx'
-backend2gui['CocoaAgg'] = 'osx'
+backend2gui["GTK"] = backend2gui["GTKCairo"] = "gtk"
+backend2gui["WX"] = "wx"
+backend2gui["CocoaAgg"] = "osx"
 
 
 def do_enable_gui(guiname):
     from _pydev_bundle.pydev_versioncheck import versionok_for_gui
+
     if versionok_for_gui():
         try:
             from pydev_ipython.inputhook import enable_gui
+
             enable_gui(guiname)
         except:
             sys.stderr.write("Failed to enable GUI event loop integration for '%s'\n" % guiname)
             pydev_log.exception()
-    elif guiname not in ['none', '', None]:
+    elif guiname not in ["none", "", None]:
         # Only print a warning if the guiname was going to do something
         sys.stderr.write("Debug console: Python version does not support GUI event loop integration for '%s'\n" % guiname)
     # Return value does not matter, so return back what was sent
@@ -41,9 +44,9 @@ def do_enable_gui(guiname):
 
 def find_gui_and_backend():
     """Return the gui and mpl backend."""
-    matplotlib = sys.modules['matplotlib']
+    matplotlib = sys.modules["matplotlib"]
     # WARNING: this assumes matplotlib 1.1 or newer!!
-    backend = matplotlib.rcParams['backend']
+    backend = matplotlib.rcParams["backend"]
     # In this case, we need to find what the appropriate gui selection call
     # should be for IPython, so we can activate inputhook accordingly
     gui = backend2gui.get(backend, None)
@@ -51,9 +54,10 @@ def find_gui_and_backend():
 
 
 def is_interactive_backend(backend):
-    """ Check if backend is interactive """
-    matplotlib = sys.modules['matplotlib']
+    """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:
@@ -63,8 +67,8 @@ def is_interactive_backend(backend):
 
 
 def patch_use(enable_gui_function):
-    """ Patch matplotlib function 'use' """
-    matplotlib = sys.modules['matplotlib']
+    """Patch matplotlib function 'use'"""
+    matplotlib = sys.modules["matplotlib"]
 
     def patched_use(*args, **kwargs):
         matplotlib.real_use(*args, **kwargs)
@@ -76,11 +80,11 @@ def patch_use(enable_gui_function):
 
 
 def patch_is_interactive():
-    """ Patch matplotlib function 'use' """
-    matplotlib = sys.modules['matplotlib']
+    """Patch matplotlib function 'use'"""
+    matplotlib = sys.modules["matplotlib"]
 
     def patched_is_interactive():
-        return matplotlib.rcParams['interactive']
+        return matplotlib.rcParams["interactive"]
 
     matplotlib.real_is_interactive = matplotlib.is_interactive
     matplotlib.is_interactive = patched_is_interactive
@@ -90,7 +94,7 @@ def activate_matplotlib(enable_gui_function):
     """Set interactive to True for interactive backends.
     enable_gui_function - Function which enables gui, should be run in the main thread.
     """
-    matplotlib = sys.modules['matplotlib']
+    matplotlib = sys.modules["matplotlib"]
     gui, backend = find_gui_and_backend()
     is_interactive = is_interactive_backend(backend)
     if is_interactive:
@@ -120,7 +124,7 @@ def flag_calls(func):
     func() was attempted and succeeded."""
 
     # don't wrap twice
-    if hasattr(func, 'called'):
+    if hasattr(func, "called"):
         return func
 
     def wrapper(*args, **kw):
@@ -135,7 +139,7 @@ def flag_calls(func):
 
 
 def activate_pylab():
-    pylab = sys.modules['pylab']
+    pylab = sys.modules["pylab"]
     pylab.show._needmain = False
     # We need to detect at runtime whether show() is called by the user.
     # For this, we wrap it into a decorator which adds a 'called' flag.
@@ -143,7 +147,7 @@ def activate_pylab():
 
 
 def activate_pyplot():
-    pyplot = sys.modules['matplotlib.pyplot']
+    pyplot = sys.modules["matplotlib.pyplot"]
     pyplot.show._needmain = False
     # We need to detect at runtime whether show() is called by the user.
     # For this, we wrap it into a decorator which adds a 'called' flag.

debugpy-1.8.7/src/debugpy/_vendored/pydevd/pydev_ipython/qt.py

@@ -0,0 +1,24 @@
+"""A Qt API selector that can be used to switch between PyQt and PySide.
+
+This uses the ETS 4.0 selection pattern of:
+PySide first, PyQt with API v2. second.
+
+Do not use this if you need PyQt with the old QString/QVariant API.
+"""
+
+import os
+
+from pydev_ipython.qt_loaders import load_qt, QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT, QT_API_PYQT5, QT_API_PYQT6
+
+QT_API = os.environ.get("QT_API", None)
+if QT_API not in [QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT, QT_API_PYQT5, QT_API_PYQT6, None]:
+    raise RuntimeError(
+        "Invalid Qt API %r, valid values are: %r, %r, %r, %r, %r"
+        % (QT_API, QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT, QT_API_PYQT5, QT_API_PYQT6)
+    )
+if QT_API is None:
+    api_opts = [QT_API_PYSIDE, QT_API_PYSIDE2, QT_API_PYQT, QT_API_PYQT5, QT_API_PYQT6]
+else:
+    api_opts = [QT_API]
+
+QtCore, QtGui, QtSvg, QT_API = load_qt(api_opts)