Source code for taurus.qt.qtgui.util.tauruswidgetfactory
#!/usr/bin/env python
# ###########################################################################
#
# This file is part of Taurus
#
# http://taurus-scada.org
#
# Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain
#
# Taurus is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Taurus is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with Taurus. If not, see <http://www.gnu.org/licenses/>.
#
# ###########################################################################
"""
tauruswidgetfactory.py:
"""
__docformat__ = "restructuredtext"
import pkg_resources
import importlib
import os.path
from taurus.external.qt import Qt
from taurus.core.util.log import Logger, deprecation_decorator
from taurus.core.util.singleton import Singleton
import taurus.qt.qtgui.base
def _getWidgetsOfType(widget, widgets, class_or_type_or_tuple):
if isinstance(widget, class_or_type_or_tuple):
widgets.append(widget)
for w in widget.children():
if isinstance(w, Qt.QWidget):
_getWidgetsOfType(w, widgets, class_or_type_or_tuple)
[docs]def getWidgetsOfType(widget, class_or_type_or_tuple):
"""Returns all widgets in a hierarchy of a certain type
:param widget: the widget to be inspected
:type widget: Qt.QWidget
:param class-or-type-or-tuple: type to be checked
:type class-or-type-or-tuple: type class or a tuple of type classes
:return: a sequence containning all widgets in the hierarchy that match the
given type
:rtype: seq<Qt.QWidget>
"""
widgets = []
_getWidgetsOfType(widget, widgets, class_or_type_or_tuple)
return widgets
[docs]class TaurusWidgetFactory(Singleton, Logger):
"""The TaurusWidgetFactory is a utility class that provides information
about all Qt widgets (Taurus and non Taurus) that are found in the
current taurus distribution.
TaurusWidgetFactory is a singleton class so you can freely create new
instances since they will all reference the same object.
Usage::
from taurus.qt.qtgui.util import TaurusWidgetFactory
wf = TaurusWidgetFactory()
print(wf.getTaurusWidgetClassNames())
"""
skip_modules = (
"widget",
"util",
"qtdesigner",
"uic",
"resource",
"console",
"style",
"plot",
)
def __init__(self):
"""Initialization. Nothing to be done here for now."""
[docs] def init(self, *args):
"""Singleton instance initialization."""
name = self.__class__.__name__
self.call__init__(Logger, name)
self.deprecated(
rel="5.0.0", dep="TaurusWidgetFactory", alt="importlib"
)
path = os.path.dirname(os.path.abspath(__file__))
path, tail = os.path.split(path)
self._taurus_widgets, self._qt_widgets = self._buildWidgets(
"taurus.qt.qtgui", path
)
# Also explore modules registered via the `taurus.qt.qtgui` entry-point
for ep in pkg_resources.iter_entry_points("taurus.qt.qtgui"):
try:
_module = ep.load()
_name = _module.__name__
_path = os.path.dirname(os.path.abspath(_module.__file__))
except Exception as e:
self.warning("Cannot explore %s. Reason: %r", ep, e)
continue
taurus_widgets, qt_widgets = self._buildWidgets(_name, _path)
self._taurus_widgets.update(taurus_widgets)
self._qt_widgets.update(qt_widgets)
self._addExtraTaurusWidgets(self._taurus_widgets, self._qt_widgets)
def _buildWidgets(self, module_name, path, recursive=True):
import taurus.qt.qtgui.base
if Qt.QApplication.instance() is None:
# keep a reference
app = Qt.QApplication([]) # noqa: F841
elems = os.listdir(path)
taurus_ret, qt_ret = {}, {}
if "__init__.py" not in elems:
return taurus_ret, qt_ret
try:
m = __import__(module_name, fromlist=["*"], level=0)
dir_names = dir(m)
for dir_name in dir_names:
if dir_name.startswith("_"):
continue
try:
attr = getattr(m, dir_name)
if issubclass(attr, Qt.QWidget):
package = m.__package__
qt_ret[dir_name] = package, attr
if issubclass(
attr, taurus.qt.qtgui.base.TaurusBaseWidget
):
taurus_ret[dir_name] = package, attr
except Exception:
pass
except Exception:
return taurus_ret, qt_ret
if not recursive:
return taurus_ret, qt_ret
for elem in elems:
abs_elem = os.path.join(path, elem)
if (
(not elem.startswith("."))
and os.path.isdir(abs_elem)
and (elem not in self.skip_modules)
):
m_name = os.path.splitext(elem)[0]
new_module_name = "%s.%s" % (module_name, m_name)
new_taurus_ret, new_qt_ret = self._buildWidgets(
new_module_name, abs_elem, True
)
taurus_ret.update(new_taurus_ret)
qt_ret.update(new_qt_ret)
return taurus_ret, qt_ret
def _addExtraTaurusWidgets(self, taurus_ret, qt_widgets):
designer_path = os.environ.get("TAURUSQTDESIGNERPATH")
if designer_path is None:
return taurus_ret
designer_path = designer_path.split(os.path.pathsep)
for path in designer_path:
self._addExtraTaurusWidgetsPath(taurus_ret, qt_widgets, path)
def _addExtraTaurusWidgetsPath(self, taurus_ret, qt_widgets, path):
self.debug("Trying extra taurus widgets in %s", path)
path = os.path.abspath(path)
if not os.path.isdir(path):
return
elems = os.listdir(path)
for elem in elems:
m_name, ext = os.path.splitext(elem)
if ext != ".py":
continue
try:
spec = importlib.util.spec_from_file_location(m_name, elem)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
except ImportError as ie:
self.debug("Could not load extra module %s:%s", m_name, ie)
continue
dir_names = dir(mod)
for dir_name in dir_names:
if dir_name.startswith("_"):
continue
if dir_name in taurus_ret:
continue
try:
attr = getattr(mod, dir_name)
if issubclass(attr, Qt.QWidget):
if issubclass(
attr, taurus.qt.qtgui.base.TaurusBaseWidget
):
qt_info = attr.getQtDesignerPluginInfo()
taurus_ret[dir_name] = qt_info["module"], attr
qt_widgets[dir_name] = qt_info["module"], attr
self.debug("registered taurus widget %s", dir_name)
except Exception:
pass
@deprecation_decorator(rel="5.0.0")
def getWidgets(self):
return self._qt_widgets
@deprecation_decorator(rel="5.0.0")
def getTaurusWidgets(self):
return self._taurus_widgets
@deprecation_decorator(rel="5.0.0")
def getWidgetClassNames(self):
return list(self._qt_widgets.keys())
@deprecation_decorator(rel="5.0.0")
def getWidgetClasses(self):
return [klass for mod_name, klass in self._qt_widgets.values()]
@deprecation_decorator(rel="5.0.0", alt="importlib")
def getWidgetClass(self, name):
return self._qt_widgets[name][1]
@deprecation_decorator(rel="5.0.0")
def getTaurusWidgetClassNames(self):
return list(self._taurus_widgets.keys())
@deprecation_decorator(rel="5.0.0")
def getTaurusWidgetClasses(self):
return [klass for mod_name, klass in self._taurus_widgets.values()]
@deprecation_decorator(rel="5.0.0", alt="importlib")
def getTaurusWidgetClass(self, name):
return self._taurus_widgets.get(name)[1]