def setData(self, index, qvalue): taurus_role = index.model().role(index.column()) str_value = Qt.from_qvariant(qvalue, str) if taurus_role in (ChannelView.Channel, ChannelView.Conditioning, ChannelView.NXPath, ChannelView.DataType): data = str_value elif taurus_role in (ChannelView.Enabled, ChannelView.Output): data = Qt.from_qvariant(qvalue, bool) elif taurus_role == ChannelView.PlotType: data = PlotType[str_value] elif taurus_role == ChannelView.Normalization: data = Normalization[str_value] elif taurus_role == ChannelView.PlotAxes: data = [a for a in str_value.split('|')] elif taurus_role == ChannelView.Shape: s = str_value try: data = eval(s, {}, {}) if not isinstance(data, (tuple, list)): raise ValueError except: from taurus.core.util.log import Logger Logger(self.__class__.__name__).error('Invalid shape %s', s) data = () else: raise NotImplementedError('Unknown role') ch_name, ch_data = self.itemData() key = self.itemdata_keys_map[taurus_role] ch_data[key] = data
def __init__(self, parent=None, name='', queue=None, method=None, cursor=None, sleep=5000): """ Parent most not be None and must be a TaurusGraphicsScene! """ Qt.QThread.__init__(self, parent) self.name = name self.log = Logger('TaurusEmitterThread(%s)' % self.name) self.log.setLogLevel(self.log.Info) self.queue = queue or Queue.Queue() self.todo = Queue.Queue() self.method = method self.cursor = Qt.QCursor( Qt.Qt.WaitCursor) if cursor is True else cursor self._cursor = False self.timewait = sleep self.emitter = Qt.QObject() self.emitter.moveToThread(Qt.QApplication.instance().thread()) # Mandatory!!! if parent is set before changing thread it could lead to # segFaults! self.emitter.setParent(Qt.QApplication.instance()) self._done = 0 # Moved to the end to prevent segfaults ... Qt.QObject.connect(self.emitter, Qt.SIGNAL("doSomething"), self._doSomething) Qt.QObject.connect(self.emitter, Qt.SIGNAL("somethingDone"), self.next)
def onModuleSelected(self): modulename = str(self.moduleNameLE.text()) try: __import__(modulename) # We use this because __import__('x.y') returns x instead of y !! self.module = sys.modules[modulename] self.moduleNameLE.setStyleSheet('QLineEdit {color: green}') except Exception as e: Logger().debug(repr(e)) self.moduleNameLE.setStyleSheet('QLineEdit {color: red}') return # inspect the module to find the members we want (classes or widgets # inheriting from QWidget) members = inspect.getmembers(self.module) classnames = sorted([ n for n, m in members if inspect.isclass(m) and issubclass(m, Qt.QWidget) ]) widgetnames = sorted( [n for n, m in members if isinstance(m, Qt.QWidget)]) self.membersCB.clear() self.membersCB.addItem(self.CHOOSE_TYPE_TXT) self.membersCB.addItems(classnames) if classnames and widgetnames: self.membersCB.InsertSeparator(self.membersCB.count()) self.membersCB.addItems(classnames)
def fromPanel(panel): name = str(panel.objectName()) classname = panel.getWidgetClassName() modulename = panel.getWidgetModuleName() # in the case of classes known to the TaurusWidgetFactory, # do not store the modulename if modulename.startswith('taurus.') and \ classname in TaurusWidgetFactory().getWidgetClassNames(): modulename = None widgetname = None floating = panel.isFloating() sharedDataWrite = None sharedDataRead = None model = getattr(panel.widget(), 'model', None) if model is None or isinstance(model, basestring): pass elif hasattr(model, '__iter__'): # if model is a sequence, convert to space-separated string try: model = " ".join(model) except Exception, e: msg = ('Cannot convert %s to a space-separated string: %s' % (model, e)) Logger().debug(msg) model = None
def parse(filename=None, factory=None): if filename is None or factory is None: return _, p = new_parser() print " \n\n\n zrobioby nowy parser" print "1: ", _ print "2: ", p p.factory = factory p.modelStack = [] p.modelStack2 = [] res = None try: filename = os.path.realpath(filename) f = open(filename) #print f.read() print "\n\n\n otwprzylem plik w try" res = yacc.parse(f.read()) #nie bylo tracking=True, dodalem #for i in res: # print "res i: ", i print "\n\n SPARSOWALEMW TRY! \n" print "\n RES: ", res except: print "\n\n NIE SPARSOWALEM W TRY" log = Logger('JDraw Parser') #print "\n\n LOG1: ", log, "\n\n\n stop" log.warning("Failed to parse %s" % filename) #print "\n\n exec info: ?" log.debug("Details:", exc_info=1) return res
def main(): from taurus.core.util.log import Logger from taurus.qt.qtgui.util import TaurusWidgetFactory Logger.setLogLevel(Logger.Debug) _log = Logger(__name__) try: wf = TaurusWidgetFactory() klasses = wf.getWidgetClasses() ok_nb, skipped_nb, e1_nb, e2_nb, e3_nb, e4_nb = 0, 0, 0, 0, 0, 0 for widget_klass in klasses: name = widget_klass.__name__ #_log.debug("Processing %s" % name) if name in _SKIP: #_log.debug("Skipped %s" % name) skipped_nb += 1 continue # if getQtDesignerPluginInfo does not exist, returns None or raises # an exception: forget the widget cont = False try: qt_info = widget_klass.getQtDesignerPluginInfo() if qt_info is None: #_log.debug("E1: Canceled %s (getQtDesignerPluginInfo)" % name) e1_nb += 1 cont = True except AttributeError: #_log.debug("E2: Canceled %s (widget doesn't have getQtDesignerPluginInfo())" % name) e2_nb += 1 cont = True except Exception, e: #_log.debug("E3: Canceled %s (%s)" % (name, str(e))) e3_nb += 1 cont = True if cont: continue for k in ('module', ): if not qt_info.has_key(k): #_log.debug("E4: Canceled %s (getQtDesignerPluginInfo doesn't have key %s)" % (name, k)) e4_nb += 1 cont = True if cont: continue plugin_klass = build_qtdesigner_widget_plugin(widget_klass) plugin_klass_name = plugin_klass.__name__ globals()[plugin_klass_name] = plugin_klass _plugins[plugin_klass_name] = plugin_klass ok_nb += 1 #_log.debug("DONE processing %s" % name) _log.info("Inpected %d widgets. %d (OK), %d (Skipped), %d (E1), %d (E2), %d (E3), %d(E4)" % ( len(klasses), ok_nb, skipped_nb, e1_nb, e2_nb, e3_nb, e4_nb)) _log.info("E1: getQtDesignerPluginInfo() returns None") _log.info("E2: widget doesn't implement getQtDesignerPluginInfo()") _log.info("E3: getQtDesignerPluginInfo() throws exception") _log.info( "E4: getQtDesignerPluginInfo() returns dictionary with missing key (probably 'module' key)")
def __init__(self, inst, props, *args, **kwargs): self._inst_name = inst self._log = Logger("Controller.%s" % inst) self._log.log_obj.setLevel(getLogLevel()) self._args = args self._kwargs = kwargs self._api_version = self._findAPIVersion() for prop_name, prop_value in list(props.items()): setattr(self, prop_name, prop_value)
def new_parser(optimize=None, debug=0, outputdir=None): log = Logger('JDraw Parser') if optimize is None: from taurus import tauruscustomsettings optimize = getattr(tauruscustomsettings, 'PLY_OPTIMIZE', 1) if outputdir is None: # use '.taurus' dir in the user "home" dir outputdir = os.path.join(os.path.expanduser('~'), '.taurus') # create the output dir if it didn't exist if not os.path.exists(outputdir): os.makedirs(outputdir) debuglog = None if debug: debuglog = log common_kwargs = dict(optimize=optimize, outputdir=outputdir, debug=debug, debuglog=debuglog, errorlog=log) # lex/yacc v<3.0 do not accept debuglog or errorlog keyword args if int(lex.__version__.split('.')[0]) < 3: common_kwargs.pop('debuglog') common_kwargs.pop('errorlog') try: _path = os.path.join(outputdir, 'jdraw_lextab.py') jdraw_lextab = imp.load_source('jdraw_lextab', _path) except: jdraw_lextab = 'jdraw_lextab' try: _path = os.path.join(outputdir, 'jdraw_yacctab.py') jdraw_yacctab = imp.load_source('jdraw_lextab', _path) except: jdraw_yacctab = 'jdraw_yacctab' # Lexer l = lex.lex(lextab=jdraw_lextab, **common_kwargs) # Yacc try: p = yacc.yacc(tabmodule=jdraw_yacctab, debugfile=None, write_tables=1, **common_kwargs) except Exception, e: msg = ( 'Error creating jdraw parser.\n' + 'HINT: Try removing jdraw_lextab.* and jdraw_yacctab.* from %s' % outputdir) raise RuntimeError(msg)
def setUp(self): self.logger = Logger('BaseControllerTestCase') if self.DEBUG: self.logger.setLogLevel(Logger.Debug) if self.KLASS is None: raise Exception('Ctrl klass has not been defined') name = 'test_ctrl' self.ctrl = self.KLASS(name, self.PROPS) self.pre_AddDevice_hook() self.ctrl.AddDevice(self.AXIS)
def initializePage(self): try: widget = self.wizard().getPanelDescription().getWidget() except Exception as e: Logger().debug(repr(e)) widget = None # prevent the user from changing the model if it was already set if isinstance(widget, TaurusBaseComponent) and widget.getModelName() != '': self.modelLE.setText("(already set by the chosen widget)") self.modelGB.setEnabled(False) # try to get the SDM as if we were in a TaurusGui app try: if isinstance(Qt.qApp.SDM, SharedDataManager): sdm = Qt.qApp.SDM except Exception as e: Logger().debug(repr(e)) sdm = None #@todo set selection filter in modelChooser based on the widget's modelclass self.itemDelegate = CommItemDelegate(widget=widget, sdm=sdm) self.commLV.setItemDelegate(self.itemDelegate)
def getMemberDescription(self): try: membername = str(self.membersCB.currentText()) member = getattr(self.module, membername, None) result = {'modulename': self.module.__name__} except Exception as e: Logger().debug('Cannot get member description: %s', repr(e)) return None if inspect.isclass(member): result['classname'] = membername else: result['widgetname'] = membername return result
def new_parser(optimize=None, debug=0, outputdir=None): log = Logger('JDraw Parser') if optimize is None: from taurus import tauruscustomsettings optimize = getattr(tauruscustomsettings, 'PLY_OPTIMIZE', 1) if outputdir is None: outputdir = os.path.dirname(os.path.realpath(__file__)) #print "\n\n\n OUTPUT dir: ", outputdir debuglog = None if debug: debuglog = log common_kwargs = dict(optimize=optimize, outputdir=outputdir, debug=debug, debuglog=debuglog, errorlog=log) # lex/yacc v<3.0 do not accept debuglog or errorlog keyword args if int(lex.__version__.split('.')[0]) < 3: common_kwargs.pop('debuglog') common_kwargs.pop('errorlog') try: from . import jdraw_lextab except ImportError: jdraw_lextab = 'jdraw_lextab' try: from . import jdraw_yacctab except ImportError: jdraw_yacctab = 'jdraw_yacctab' # Lexer l = lex.lex(lextab=jdraw_lextab, **common_kwargs) # Yacc try: p = yacc.yacc(tabmodule=jdraw_yacctab, debugfile=None, write_tables=1, **common_kwargs) except Exception, e: print "\n\n Nie udal sie yacc yaccc" msg = ('Error while parsing. You may solve it by:\n' + \ ' a) removing jdraw_lextab.* and jdraw_yacctab.* from\n' +\ ' %s , or...\n' % os.path.dirname(__file__) + \ ' b) setting PLY_OPTIMIZE=0 in tauruscustomsettings.py') raise RuntimeError(msg)
def __init__(self, parent=None, name='', queue=None, method=None, cursor=None, sleep=5000, polling=0, loopwait=5): """ Parent must be not None and must be a TaurusGraphicsScene! :param queue: pass an external action queue (optional) :param method: action processor (e.g. modelSetter) :param cursor: QCursor during process (optional) :param sleep: delay in ms before thread start :param polling: process actions at fix period (milliseconds) :param loopwait: wait N milliseconds between actions """ Qt.QThread.__init__(self, parent) self.name = name self.log = Logger('TaurusEmitterThread(%s)' % self.name) self.log.setLogLevel(self.log.Info) self.queue = queue or Queue() self.todo = Queue() self.method = method self.cursor = Qt.QCursor( Qt.Qt.WaitCursor) if cursor is True else cursor self._cursor = False self.timewait = int(sleep) self.polling = int(polling) self.loopwait = int(loopwait) if self.polling: self.refreshTimer = Qt.QTimer() self.refreshTimer.timeout.connect(self.onRefresh) else: self.refreshTimer = None self.emitter = QEmitter() self.emitter.moveToThread(Qt.QApplication.instance().thread()) # Mandatory!!! if parent is set before changing thread it could lead to # segFaults! self.emitter.setParent(Qt.QApplication.instance()) self._done = 0 # Moved to the end to prevent segfaults ... self.emitter.doSomething.connect(self._doSomething) if not self.refreshTimer: self.emitter.somethingDone.connect(self.next)
def __init__(self, parent=None, name='', queue=None, method=None, cursor=None, sleep=5000, log=Logger.Warning, start=True): self.name = name self.log = Logger('SingletonWorker(%s)' % self.name) self.log.setLogLevel(log) self.log.info('At SingletonWorker.__init__(%s)' % self.name) self.parent = parent self.method = method self._running = False if SingletonWorker._thread is None: SingletonWorker._thread = TaurusEmitterThread( parent, name='SingletonWorker', cursor=cursor, sleep=sleep) self.thread = SingletonWorker._thread self.queue = queue or Queue.Queue() if start: self.start()
def fromPanel(panel): name = str(panel.objectName()) classname = panel.getWidgetClassName() modulename = panel.getWidgetModuleName() # in the case of classes known to the TaurusWidgetFactory, # do not store the modulename if modulename.startswith('taurus.') and \ classname in TaurusWidgetFactory().getWidgetClassNames(): modulename = None widgetname = None floating = panel.isFloating() sharedDataWrite = None sharedDataRead = None model = getattr(panel.widget(), 'model', None) if model is None or isinstance(model, string_types): pass elif hasattr(model, '__iter__'): # if model is a sequence, convert to space-separated string try: model = " ".join(model) except Exception as e: msg = ('Cannot convert %s to a space-separated string: %s' % (model, e)) Logger().debug(msg) model = None else: # ignore other "model" attributes (they are not from Taurus) model = None return PanelDescription(name, classname=classname, modulename=modulename, widgetname=widgetname, floating=floating, sharedDataWrite=sharedDataWrite, sharedDataRead=sharedDataRead, model=model, icon=panel.icon, model_in_config=panel.model_in_config, modifiable_by_user=panel.modifiable_by_user, widget_formatter=panel.widget_formatter, widget_properties=panel.widget_properties)
def parse(filename=None, factory=None): if filename is None or factory is None: return _, p = new_parser() p.factory = factory p.modelStack = [] p.modelStack2 = [] res = None try: filename = os.path.realpath(filename) f = open(filename) res = yacc.parse(f.read()) except: log = Logger('JDraw Parser') log.warning("Failed to parse %s" % filename) log.debug("Details:", exc_info=1) return res
def setData(self, index, qvalue): ch_name, ch_data = self.itemData() taurus_role = index.model().role(index.column()) key = self.itemdata_keys_map[taurus_role] if taurus_role in (ChannelView.Channel, ChannelView.Conditioning, ChannelView.NXPath, ChannelView.Enabled, ChannelView.Output, ChannelView.ValueRefEnabled, ChannelView.ValueRefPattern): data = qvalue elif taurus_role == ChannelView.DataType: if len(qvalue.strip()) == 0: # empty strings are considered as unspecified data type try: ch_data.pop(key) except KeyError: pass # data_type key may not be there if not specified return else: data = qvalue elif taurus_role == ChannelView.PlotType: data = PlotType[qvalue] elif taurus_role == ChannelView.Normalization: data = Normalization[qvalue] elif taurus_role == ChannelView.PlotAxes: data = [a for a in qvalue.split('|')] elif taurus_role == ChannelView.Shape: s = qvalue try: data = eval(s, {}, {}) if not isinstance(data, (tuple, list)): raise ValueError except: from taurus.core.util.log import Logger Logger(self.__class__.__name__).error('Invalid shape %s', s) data = () else: raise NotImplementedError('Unknown role') ch_data[key] = data
from __future__ import print_function import inspect from taurus.external.qt import Qt from taurus.external.qt import QtDesigner from taurus.core.util.log import Logger def Q_TYPEID(class_name): """ Helper function to generate an IID for Qt.""" return "com.trolltech.Qt.Designer.%s" % class_name designer_logger = Logger("PyQtDesigner") class TaurusWidgetPlugin(QtDesigner.QPyDesignerCustomWidgetPlugin): """TaurusWidgetPlugin""" def __init__(self, parent=None): QtDesigner.QPyDesignerCustomWidgetPlugin.__init__(self) self._log = Logger(self._getWidgetClassName(), designer_logger) self.initialized = False def initialize(self, formEditor): """ Overwrite if necessary. Don't forget to call this method in case you want the generic taurus extensions in your widget.""" if self.isInitialized(): return
def __init__(self, parent=None): QtDesigner.QPyDesignerCustomWidgetPlugin.__init__(self) self._log = Logger(self._getWidgetClassName(), designer_logger) self.initialized = False
def __init__(self, parent=None, **kwargs): if Qt.QT_VERSION < 0x050000: # Workaround for issue when using super with pyqt<5 BaseConfigurableClass.__init__(self) PlotWidget.__init__(self, parent=parent, **kwargs) else: super(TaurusPlot, self).__init__(parent=None, **kwargs) # Compose with a Logger self._logger = Logger(name=self.__class__.__name__) self.debug = self._logger.debug self.info = self._logger.info self.warning = self._logger.warning self.error = self._logger.error # set up cyclic color generator self._curveColors = LoopList(CURVE_COLORS) self._curveColors.setCurrentIndex(-1) # add save & retrieve configuration actions menu = self.getPlotItem().getViewBox().menu saveConfigAction = QtGui.QAction("Save configuration", menu) saveConfigAction.triggered.connect(self._onSaveConfigAction) menu.addAction(saveConfigAction) loadConfigAction = QtGui.QAction("Retrieve saved configuration", menu) loadConfigAction.triggered.connect(self._onRetrieveConfigAction) menu.addAction(loadConfigAction) self.registerConfigProperty(self._getState, self.restoreState, "state") # add legend tool legend_tool = PlotLegendTool(self) legend_tool.attachToPlotItem(self.getPlotItem()) # add model chooser self._model_chooser_tool = TaurusXYModelChooserTool(self) self._model_chooser_tool.attachToPlotItem(self.getPlotItem(), self, self._curveColors) # add Y2 axis self._y2 = Y2ViewBox() self._y2.attachToPlotItem(self.getPlotItem()) # add plot configuration dialog self._cprop_tool = CurvesPropertiesTool(self) self._cprop_tool.attachToPlotItem(self.getPlotItem(), y2=self._y2) # add a data inspector inspector_tool = DataInspectorTool(self) inspector_tool.attachToPlotItem(self.getPlotItem()) # enable Autorange self.getPlotItem().getViewBox().enableAutoRange(True) self._y2.enableAutoRange(True) # Register config properties self.registerConfigDelegate(self._model_chooser_tool, "XYmodelchooser") self.registerConfigDelegate(self._y2, "Y2Axis") self.registerConfigDelegate(self._cprop_tool, "CurvePropertiesTool") self.registerConfigDelegate(legend_tool, "legend") self.registerConfigDelegate(inspector_tool, "inspector")
servers It is not a replacement of the Tango Starter Device Server since this is much more limited in scope. """ __docformat__ = 'restructuredtext' import os import time import subprocess import PyTango from taurus.core.util.log import Logger _log = Logger('Starter') class Starter(object): '''Abstract class for managing (starting, stopping, registering and removing) a Tango Device Server. Derived classes should provide the methods for starting and stopping a device. ''' def __init__(self, ds_name): ''' :param ds_name: (str) Device Server name in the form "server/instance" ''' self.ds_name = ds_name self.dserver_name = 'dserver/%s' % ds_name
def log_dependencies(): from taurus.core.util.log import Logger l = Logger("taurus") for msg in _check_dependencies(forlog=True): if msg[0] != -1: l.info(msg[1])
'getStandardIcon', 'getElementTypeToolTip', 'getElementTypeIconName', 'getElementTypeIcon', 'getElementTypePixmap', 'getElementTypeSize', 'getDevStateToolTip', 'getDevStateIcon', 'getDevStatePixmap', 'getThemeMembers' ] __docformat__ = 'restructuredtext' import os from taurus.external.qt import Qt from taurus.core.taurusbasetypes import TaurusElementType, TaurusDevState from taurus.core.util.log import Logger, tep14_deprecation __LOGGER = Logger(__name__) ElemType = TaurusElementType Size = Qt.QSize __INITIALIZED = False # Theme capacity was only added in Qt 4.6 __THEME_CAPACITY = hasattr(Qt.QIcon, "fromTheme") # Uncomment the following line to force NOT to use OS theme. #__THEME_CAPACITY = False __THEME_MEMBERS = {} # Default width, height and QSize constants __DW = 70 __DH = 24
def _getLogger(): global _LOGGER if _LOGGER is None: _LOGGER = Logger('Grabber') return _LOGGER
def __init__(self, parent=None, **kwargs): if Qt.QT_VERSION < 0x050000: # Workaround for issue when using super with pyqt<5 BaseConfigurableClass.__init__(self) PlotWidget.__init__(self, parent=parent, **kwargs) else: super(TaurusTrend, self).__init__(parent=parent, **kwargs) # Compose with a Logger self._logger = Logger(name=self.__class__.__name__) self.debug = self._logger.debug self.info = self._logger.info self.warning = self._logger.warning self.error = self._logger.error # set up cyclic color generator self._curveColors = LoopList(CURVE_COLORS) self._curveColors.setCurrentIndex(-1) plot_item = self.getPlotItem() menu = plot_item.getViewBox().menu # add save & retrieve configuration actions saveConfigAction = QtGui.QAction("Save configuration", menu) saveConfigAction.triggered.connect(self.saveConfigFile) menu.addAction(saveConfigAction) loadConfigAction = QtGui.QAction("Retrieve saved configuration", menu) loadConfigAction.triggered.connect(self.loadConfigFile) menu.addAction(loadConfigAction) self.registerConfigProperty(self._getState, self.restoreState, "state") # add legend tool legend_tool = PlotLegendTool(self) legend_tool.attachToPlotItem(plot_item) # add model chooser self._model_chooser_tool = TaurusXYModelChooserTool( self, itemClass=TaurusTrendSet, showX=False) self._model_chooser_tool.attachToPlotItem(self.getPlotItem(), self, self._curveColors) # add Y2 axis self._y2 = Y2ViewBox() self._y2.attachToPlotItem(plot_item) # Add time X axis axis = DateAxisItem(orientation="bottom") axis.attachToPlotItem(plot_item) # add plot configuration dialog self._cprop_tool = CurvesPropertiesTool(self) self._cprop_tool.attachToPlotItem(plot_item, y2=self._y2) # add data inspector widget inspector_tool = DataInspectorTool(self) inspector_tool.attachToPlotItem(self.getPlotItem()) # add force read tool self._fr_tool = ForcedReadTool(self) self._fr_tool.attachToPlotItem(self.getPlotItem()) # Add the auto-pan ("oscilloscope mode") tool self._autopan = XAutoPanTool() self._autopan.attachToPlotItem(self.getPlotItem()) # Register config properties self.registerConfigDelegate(self._model_chooser_tool, "XYmodelchooser") # self.registerConfigDelegate(self._y2, "Y2Axis") self.registerConfigDelegate(self._cprop_tool, "CurvePropertiesTool") self.registerConfigDelegate(legend_tool, "legend") self.registerConfigDelegate(self._fr_tool, "forceread") self.registerConfigDelegate(inspector_tool, "inspector")