Download omnilmm/lib/python3.10/site-packages/matplotlib/backends/qt_compat.py from ZTWHHH/envs_2: direct link, hf CLI and curl.
- Browser
- Download file 8.81 kB
-
https://huggingface.co/datasets/ZTWHHH/envs_2/resolve/main/omnilmm/lib/python3.10/site-packages/matplotlib/backends/qt_compat.py
- Command line
-
hf download hf://datasets/ZTWHHH/envs_2/omnilmm/lib/python3.10/site-packages/matplotlib/backends/qt_compat.py
-
curl -L -o qt_compat.py https://huggingface.co/datasets/ZTWHHH/envs_2/resolve/main/omnilmm/lib/python3.10/site-packages/matplotlib/backends/qt_compat.py
8.81 kB
| """ | |
| Qt binding and backend selector. | |
| The selection logic is as follows: | |
| - if any of PyQt6, PySide6, PyQt5, or PySide2 have already been | |
| imported (checked in that order), use it; | |
| - otherwise, if the QT_API environment variable (used by Enthought) is set, use | |
| it to determine which binding to use; | |
| - otherwise, use whatever the rcParams indicate. | |
| """ | |
| import functools | |
| import operator | |
| import os | |
| import platform | |
| import sys | |
| import signal | |
| import socket | |
| import contextlib | |
| from packaging.version import parse as parse_version | |
| import matplotlib as mpl | |
| from . import _QT_FORCE_QT5_BINDING | |
| QT_API_PYQT6 = "PyQt6" | |
| QT_API_PYSIDE6 = "PySide6" | |
| QT_API_PYQT5 = "PyQt5" | |
| QT_API_PYSIDE2 = "PySide2" | |
| QT_API_ENV = os.environ.get("QT_API") | |
| if QT_API_ENV is not None: | |
| QT_API_ENV = QT_API_ENV.lower() | |
| _ETS = { # Mapping of QT_API_ENV to requested binding. | |
| "pyqt6": QT_API_PYQT6, "pyside6": QT_API_PYSIDE6, | |
| "pyqt5": QT_API_PYQT5, "pyside2": QT_API_PYSIDE2, | |
| } | |
| # First, check if anything is already imported. | |
| if sys.modules.get("PyQt6.QtCore"): | |
| QT_API = QT_API_PYQT6 | |
| elif sys.modules.get("PySide6.QtCore"): | |
| QT_API = QT_API_PYSIDE6 | |
| elif sys.modules.get("PyQt5.QtCore"): | |
| QT_API = QT_API_PYQT5 | |
| elif sys.modules.get("PySide2.QtCore"): | |
| QT_API = QT_API_PYSIDE2 | |
| # Otherwise, check the QT_API environment variable (from Enthought). This can | |
| # only override the binding, not the backend (in other words, we check that the | |
| # requested backend actually matches). Use _get_backend_or_none to avoid | |
| # triggering backend resolution (which can result in a partially but | |
| # incompletely imported backend_qt5). | |
| elif (mpl.rcParams._get_backend_or_none() or "").lower().startswith("qt5"): | |
| if QT_API_ENV in ["pyqt5", "pyside2"]: | |
| QT_API = _ETS[QT_API_ENV] | |
| else: | |
| _QT_FORCE_QT5_BINDING = True # noqa | |
| QT_API = None | |
| # A non-Qt backend was selected but we still got there (possible, e.g., when | |
| # fully manually embedding Matplotlib in a Qt app without using pyplot). | |
| elif QT_API_ENV is None: | |
| QT_API = None | |
| elif QT_API_ENV in _ETS: | |
| QT_API = _ETS[QT_API_ENV] | |
| else: | |
| raise RuntimeError( | |
| "The environment variable QT_API has the unrecognized value {!r}; " | |
| "valid values are {}".format(QT_API_ENV, ", ".join(_ETS))) | |
| def _setup_pyqt5plus(): | |
| global QtCore, QtGui, QtWidgets, __version__ | |
| global _getSaveFileName, _isdeleted, _to_int | |
| if QT_API == QT_API_PYQT6: | |
| from PyQt6 import QtCore, QtGui, QtWidgets, sip | |
| __version__ = QtCore.PYQT_VERSION_STR | |
| QtCore.Signal = QtCore.pyqtSignal | |
| QtCore.Slot = QtCore.pyqtSlot | |
| QtCore.Property = QtCore.pyqtProperty | |
| _isdeleted = sip.isdeleted | |
| _to_int = operator.attrgetter('value') | |
| elif QT_API == QT_API_PYSIDE6: | |
| from PySide6 import QtCore, QtGui, QtWidgets, __version__ | |
| import shiboken6 | |
| def _isdeleted(obj): return not shiboken6.isValid(obj) | |
| if parse_version(__version__) >= parse_version('6.4'): | |
| _to_int = operator.attrgetter('value') | |
| else: | |
| _to_int = int | |
| elif QT_API == QT_API_PYQT5: | |
| from PyQt5 import QtCore, QtGui, QtWidgets | |
| import sip | |
| __version__ = QtCore.PYQT_VERSION_STR | |
| QtCore.Signal = QtCore.pyqtSignal | |
| QtCore.Slot = QtCore.pyqtSlot | |
| QtCore.Property = QtCore.pyqtProperty | |
| _isdeleted = sip.isdeleted | |
| _to_int = int | |
| elif QT_API == QT_API_PYSIDE2: | |
| from PySide2 import QtCore, QtGui, QtWidgets, __version__ | |
| try: | |
| from PySide2 import shiboken2 | |
| except ImportError: | |
| import shiboken2 | |
| def _isdeleted(obj): | |
| return not shiboken2.isValid(obj) | |
| _to_int = int | |
| else: | |
| raise AssertionError(f"Unexpected QT_API: {QT_API}") | |
| _getSaveFileName = QtWidgets.QFileDialog.getSaveFileName | |
| if QT_API in [QT_API_PYQT6, QT_API_PYQT5, QT_API_PYSIDE6, QT_API_PYSIDE2]: | |
| _setup_pyqt5plus() | |
| elif QT_API is None: # See above re: dict.__getitem__. | |
| if _QT_FORCE_QT5_BINDING: | |
| _candidates = [ | |
| (_setup_pyqt5plus, QT_API_PYQT5), | |
| (_setup_pyqt5plus, QT_API_PYSIDE2), | |
| ] | |
| else: | |
| _candidates = [ | |
| (_setup_pyqt5plus, QT_API_PYQT6), | |
| (_setup_pyqt5plus, QT_API_PYSIDE6), | |
| (_setup_pyqt5plus, QT_API_PYQT5), | |
| (_setup_pyqt5plus, QT_API_PYSIDE2), | |
| ] | |
| for _setup, QT_API in _candidates: | |
| try: | |
| _setup() | |
| except ImportError: | |
| continue | |
| break | |
| else: | |
| raise ImportError( | |
| "Failed to import any of the following Qt binding modules: {}" | |
| .format(", ".join(_ETS.values()))) | |
| else: # We should not get there. | |
| raise AssertionError(f"Unexpected QT_API: {QT_API}") | |
| _version_info = tuple(QtCore.QLibraryInfo.version().segments()) | |
| if _version_info < (5, 10): | |
| raise ImportError( | |
| f"The Qt version imported is " | |
| f"{QtCore.QLibraryInfo.version().toString()} but Matplotlib requires " | |
| f"Qt>=5.10") | |
| # Fixes issues with Big Sur | |
| # https://bugreports.qt.io/browse/QTBUG-87014, fixed in qt 5.15.2 | |
| if (sys.platform == 'darwin' and | |
| parse_version(platform.mac_ver()[0]) >= parse_version("10.16") and | |
| _version_info < (5, 15, 2)): | |
| os.environ.setdefault("QT_MAC_WANTS_LAYER", "1") | |
| # PyQt6 enum compat helpers. | |
| def _enum(name): | |
| # foo.bar.Enum.Entry (PyQt6) <=> foo.bar.Entry (non-PyQt6). | |
| return operator.attrgetter( | |
| name if QT_API == 'PyQt6' else name.rpartition(".")[0] | |
| )(sys.modules[QtCore.__package__]) | |
| # Backports. | |
| def _exec(obj): | |
| # exec on PyQt6, exec_ elsewhere. | |
| obj.exec() if hasattr(obj, "exec") else obj.exec_() | |
| def _maybe_allow_interrupt(qapp): | |
| """ | |
| This manager allows to terminate a plot by sending a SIGINT. It is | |
| necessary because the running Qt backend prevents Python interpreter to | |
| run and process signals (i.e., to raise KeyboardInterrupt exception). To | |
| solve this one needs to somehow wake up the interpreter and make it close | |
| the plot window. We do this by using the signal.set_wakeup_fd() function | |
| which organizes a write of the signal number into a socketpair connected | |
| to the QSocketNotifier (since it is part of the Qt backend, it can react | |
| to that write event). Afterwards, the Qt handler empties the socketpair | |
| by a recv() command to re-arm it (we need this if a signal different from | |
| SIGINT was caught by set_wakeup_fd() and we shall continue waiting). If | |
| the SIGINT was caught indeed, after exiting the on_signal() function the | |
| interpreter reacts to the SIGINT according to the handle() function which | |
| had been set up by a signal.signal() call: it causes the qt_object to | |
| exit by calling its quit() method. Finally, we call the old SIGINT | |
| handler with the same arguments that were given to our custom handle() | |
| handler. | |
| We do this only if the old handler for SIGINT was not None, which means | |
| that a non-python handler was installed, i.e. in Julia, and not SIG_IGN | |
| which means we should ignore the interrupts. | |
| """ | |
| old_sigint_handler = signal.getsignal(signal.SIGINT) | |
| handler_args = None | |
| skip = False | |
| if old_sigint_handler in (None, signal.SIG_IGN, signal.SIG_DFL): | |
| skip = True | |
| else: | |
| wsock, rsock = socket.socketpair() | |
| wsock.setblocking(False) | |
| old_wakeup_fd = signal.set_wakeup_fd(wsock.fileno()) | |
| sn = QtCore.QSocketNotifier( | |
| rsock.fileno(), _enum('QtCore.QSocketNotifier.Type').Read | |
| ) | |
| # We do not actually care about this value other than running some | |
| # Python code to ensure that the interpreter has a chance to handle the | |
| # signal in Python land. We also need to drain the socket because it | |
| # will be written to as part of the wakeup! There are some cases where | |
| # this may fire too soon / more than once on Windows so we should be | |
| # forgiving about reading an empty socket. | |
| rsock.setblocking(False) | |
| # Clear the socket to re-arm the notifier. | |
| def _may_clear_sock(*args): | |
| try: | |
| rsock.recv(1) | |
| except BlockingIOError: | |
| pass | |
| def handle(*args): | |
| nonlocal handler_args | |
| handler_args = args | |
| qapp.quit() | |
| signal.signal(signal.SIGINT, handle) | |
| try: | |
| yield | |
| finally: | |
| if not skip: | |
| wsock.close() | |
| rsock.close() | |
| sn.setEnabled(False) | |
| signal.set_wakeup_fd(old_wakeup_fd) | |
| signal.signal(signal.SIGINT, old_sigint_handler) | |
| if handler_args is not None: | |
| old_sigint_handler(*handler_args) | |