def delete_device(self): SardanaDevice.delete_device(self) self._macro_server.clear_log_report() # Workaround for bug #494. factory = taurus.Factory("tango") for attr in factory.tango_attrs.values(): attr.cleanUp()
def getNames(self, fullname, factory=None): """reimplemented from :class:`TaurusDeviceNameValidator`. """ groups = self.getUriGroups(fullname) if groups is None: return None default_authority = taurus.Factory("tango").get_default_tango_host() if default_authority is None: import PyTango host, port = PyTango.ApiUtil.get_env_var('TANGO_HOST').split(":") # Get the fully qualified domain name host = socket.getfqdn(host) default_authority = "//{0}:{1}".format(host, port) authority = groups.get('authority') if authority is None: groups['authority'] = authority = default_authority complete = self.scheme + ':%(authority)s?db=%(arch_db)s' % groups if authority.lower() == default_authority.lower(): normal = '?db=%(arch_db)s' % groups else: normal = '%(authority)s?db=%(arch_db)s' % groups short = '%(arch_db)s' % groups return complete, normal, short
def registerExtensions(): """Registers the pool extensions in the :class:`taurus.core.tango.TangoFactory`""" import taurus #import sardana.taurus.core.tango.sardana.pool # sardana.taurus.core.tango.sardana.pool.registerExtensions() factory = taurus.Factory() #factory.registerDeviceClass('Pool', QPool) factory.registerDeviceClass('MeasurementGroup', QMeasurementGroup)
def __init__(self, parent=None, selectables=None, host=None, designMode=None, singleModel=False): '''Creator of TaurusModelChooser :param parent: (QObject) parent for the dialog :param selectables: (list<TaurusElementType>) if passed, only elements of the tree whose type is in the list will be selectable. :param host: (QObject) Tango host to be explored by the chooser :param designMode: (bool) needed for taurusdesigner but ignored here :param singleModel: (bool) If True, the selection will be of just one model. Otherwise (default) a list of models can be selected ''' TaurusWidget.__init__(self, parent) if host is None: try: # TODO: Tango-centric! host = taurus.Factory('tango').getAuthority().getFullName() except Exception as e: taurus.info('Cannot populate Tango Tree: %r', e) self._allowDuplicates = False self.setLayout(Qt.QVBoxLayout()) self.tree = TaurusModelSelectorTree(selectables=selectables, buttonsPos=Qt.Qt.BottomToolBarArea) self.tree.setModel(host) self.list = TaurusModelList() self.list.setSelectionMode(Qt.QAbstractItemView.ExtendedSelection) applyBT = Qt.QToolButton() applyBT.setToolButtonStyle(Qt.Qt.ToolButtonTextBesideIcon) applyBT.setText('Apply') applyBT.setIcon(Qt.QIcon("status:available.svg")) self.setSingleModelMode(singleModel) # toolbar self._toolbar = self.tree._toolbar self._toolbar.addAction(self.list.removeSelectedAction) self._toolbar.addAction(self.list.removeAllAction) self._toolbar.addAction(self.list.moveUpAction) self._toolbar.addAction(self.list.moveDownAction) self._toolbar.addSeparator() self._toolbar.addWidget(applyBT) self.layout().addWidget(self.tree) self.layout().addWidget(self.list) # self.tree.setUseParentModel(True) #It does not work!!!! # @todo: This is Workaround because UseSetParentModel is giving trouble again! self.modelChanged.connect(self.tree.setModel) # connections: self.tree.addModels.connect(self.addModels) applyBT.clicked.connect(self._onUpdateModels)
def init_taurus_args(parser=None, args=None, values=None): """Parses the command line using :func:`taurus.core.util.argparse.parse_taurus_args`. After the command line is parsed, actions are taken on each recognized parameter. For example, the taurus log level and the default tango host are set accordingly. :param parser: an option parser or None (default) to create a new parser :type parser: :class:`optparse.OptionParser` :param args: the list of arguments to process (default is None meaning: sys.argv[1:]) :type args: seq<str> :param values: a :class:`optparse.Values` object to store option arguments in (default is None meaning: a new instance of Values) - if you give an existing object, the option defaults will not be initialized on it :return: a tuple of three elements: parser, options, args :rtype: :class:`optparse.OptionParser`, :class:`optparse.Values`, seq<str> """ import taurus parser, options, args = parse_taurus_args(parser=parser, args=args, values=values) # initialize taurus log level log_level_str = options.taurus_log_level.capitalize() if hasattr(taurus, log_level_str): log_level = getattr(taurus, log_level_str) taurus.setLogLevel(log_level) # initialize tango host if options.tango_host is not None: tango_factory = taurus.Factory("tango") tango_host = options.tango_host tango_factory.set_default_tango_host(tango_host) # initialize taurus polling period if options.taurus_polling_period is not None: taurus.Manager().changeDefaultPollingPeriod( options.taurus_polling_period) # initialize taurus serialization mode if options.taurus_serialization_mode is not None: import taurus.core.taurusbasetypes SerMode = taurus.core.taurusbasetypes.TaurusSerializationMode m = options.taurus_serialization_mode.capitalize() if hasattr(SerMode, m): m = getattr(SerMode, m) taurus.Manager().setSerializationMode(m) # initialize remote console port if options.remote_console_port is not None: try: import rfoo.utils.rconsole rfoo.utils.rconsole.spawn_server(port=options.remote_console_port) taurus.info( "rconsole started. You can connect to it by typing: rconsole -p %d", options.remote_console_port) except Exception, e: taurus.warning("Cannot spawn debugger. Reason: %s", str(e))
def registerExtensions(): """Registers the image extensions in the :class:`taurus.core.tango.TangoFactory`""" import taurus factory = taurus.Factory('tango') factory.registerDeviceClass('PyImageViewer', PyImageViewer) factory.registerDeviceClass('ImgGrabber', ImgGrabber) factory.registerDeviceClass('ImgBeamAnalyzer', ImgBeamAnalyzer) factory.registerDeviceClass('CCDPVCAM', CCDPVCAM) factory.registerDeviceClass('Falcon', Falcon) factory.registerDeviceClass('LimaCCDs', LimaCCDs)
def _getSimpleNameFromExpression(self, expression): """Get the simple name of an evaluationAttribute from an expression""" name = expression for ref in self.getRefs(expression, ign_quoted=True): manager = taurus.core.TaurusManager() scheme = manager.getScheme(ref) _f = taurus.Factory(scheme) attrNameValidator = _f.getAttributeNameValidator() _, _, simple_name = attrNameValidator.getNames(ref) name = self.replaceUnquotedRef(name, '{%s}' % ref, simple_name) return name
def _cleanup_device(dev_name): factory = taurus.Factory() device = taurus.Device(dev_name) # tango_alias_devs contains any names in which we have referred # to the device, could be alias, short name, etc. pop all of them for k, v in factory.tango_alias_devs.items(): if v is device: factory.tango_alias_devs.pop(k) full_name = device.getFullName() if full_name in factory.tango_devs: factory.tango_devs.pop(full_name) device.cleanUp()
def _expandRefNames(self, attrname): """Expand the refs in an eval name to their full names""" name = attrname for ref in self.getRefs(attrname, ign_quoted=True): manager = taurus.core.TaurusManager() scheme = manager.getScheme(ref) _f = taurus.Factory(scheme) attrNameValidator = _f.getAttributeNameValidator() full_name, _, _ = attrNameValidator.getNames(ref) if full_name is None: debug('Cannot expand the fullname of %s' % ref) return None name = self.replaceUnquotedRef(name, '{%s}' % ref, '{%s}' % full_name) return name
def __init__(self, schema, parent=None, sleep=10000, pause=5, period=0): self._schema = schema self.call__init__(Logger, 'DelayedSubscriber(%s)' % self._schema, None) self._factory = taurus.Factory(schema) self._modelsQueue = Queue() self._modelsThread = TaurusEmitterThread(parent=parent, queue=self._modelsQueue, method=self._modelSubscriber, sleep=sleep, loopwait=pause, polling=period) self._modelsQueue.put((self.addUnsubscribedAttributes, )) self._modelsThread.start()
def registerExtensions(): """Registers the macroserver extensions in the :class:`taurus.core.tango.TangoFactory`""" import taurus factory = taurus.Factory() factory.registerDeviceClass('MacroServer', QMacroServer) factory.registerDeviceClass('Door', QDoor) # ugly access to qtgui level: in future find a better way to register error # handlers, maybe in TangoFactory & TaurusManager import sardana.taurus.core.tango.sardana.macro import taurus.qt.qtgui.panel MacroRunException = sardana.taurus.core.tango.sardana.macro.MacroRunException TaurusMessagePanel = taurus.qt.qtgui.panel.TaurusMessagePanel TaurusMessagePanel.registerErrorHandler( MacroRunException, MacroServerMessageErrorHandler)
def __init__(self, parent=None): QtGui.QToolBar.__init__(self, parent) self.setIconSize(Qt.QSize(30, 30)) self.SnapApp = snapWidget() self.att_table = [] self.factory = taurus.Factory() self.refresh() self.refreshTimer = QtCore.QTimer() QtCore.QObject.connect(self.refreshTimer, QtCore.SIGNAL("timeout()"), self.refresh) self.refreshTimer.start(5000) snap = self.SnapApp.show self.addAction(Qt.QIcon(":/devices/camera-photo.svg"), "Snapshot Widget", snap) self.setMovable(True) self.setFloatable(True) self.setToolTip("Snapshot Toolbar")
def tearDown(self): """Remove the elements and the controllers """ dirty_elems = [] dirty_ctrls = [] f = taurus.Factory() for elem_name in self.elem_list: # Cleanup eventual taurus devices. This is especially important # if the sardana-taurus extensions are in use since this # devices are created and destroyed within the testsuite. # Persisting taurus device may react on API_EventTimeouts, enabled # polling, etc. if elem_name in f.tango_alias_devs: _cleanup_device(elem_name) try: if os.name != "nt": self.pool.DeleteElement(elem_name) except Exception as e: print(e) dirty_elems.append(elem_name) for ctrl_name in self.ctrl_list: # Cleanup eventual taurus devices. This is especially important # if the sardana-taurus extensions are in use since this # devices are created and destroyed within the testsuite. # Persisting taurus device may react on API_EventTimeouts, enabled # polling, etc. if ctrl_name in f.tango_alias_devs: _cleanup_device(ctrl_name) try: if os.name != "nt": self.pool.DeleteElement(ctrl_name) except: dirty_ctrls.append(ctrl_name) _cleanup_device(self.pool_name) BasePoolTestCase.tearDown(self) if dirty_elems or dirty_ctrls: msg = "Cleanup failed. Database may be left dirty." + \ "\n\tCtrls : %s\n\tElems : %s" % (dirty_ctrls, dirty_elems) raise Exception(msg)
def setModel(self, model, pixmap=None): """ Set Model is the callback used in shareDataManager to manage device selections. :param model: Model to VaccaPanel :param pixmap: :return: """ try: #self.setLogLevel(self.Debug) self.info('VaccaPanel(%s).setModel(%s,%s)' % (id(self), model, pixmap)) self.checkDropSupport( ) #<< Needed to reapply drop support overriden by taurusgui.ini model, modelclass, raw = str(model).strip(), '', model model = fandango.tango.parse_tango_model(model) if model is None: self.warning( 'VaccaPanel(%s).setModel(%s,%s): MODEL NOT PARSABLE!' % (id(self), model, pixmap)) return else: model = model['device'] if model: model = model and model.split()[0] or '' modelclass = taurus.Factory().findObjectClass(model) self.debug('In TaurusDevicePanel.setModel(%s(%s),%s)' % (raw, modelclass, pixmap)) if model == self.getModel(): return elif raw is None or not model or not modelclass: if self.getModel(): self.detach() return elif issubclass(modelclass, TaurusAttribute): #if model.lower().endswith('/state'): model = model.rsplit('/', 1)[0] elif not issubclass(modelclass, TaurusDevice): self.warning('TaurusDevicePanel accepts only Device models') return except Exception, e: traceback.print_exc() raise e
def __init__(self, parent=None, taurusItemsConf=None, showXcol=True): super(TaurusItemConfDlg, self).__init__(parent) self.loadUi() self._showXcol = showXcol if taurusItemsConf is None: taurusItemsConf = [ TaurusItemConf(YModel=None, XModel=None, name=None) ] self.ui.tangoTree.setButtonsPos(Qt.Qt.RightToolBarArea) # @todo: The action for this button is not yet implemented self.ui.reloadBT.setEnabled(False) self.model = TaurusCurveItemTableModel(taurusItemsConf) table = self.ui.curvesTable table.setModel(self.model) table.setColumnHidden(X, not self._showXcol) # ------------------------------------------------------------------- # I get "UnboundLocalError: local variable 'taurus' referenced before # assignment" if I don't import taurus again here # TODO: check if this workaround is really needed import taurus # ------------------------------------------------------------------- try: # TODO: Tango-centric! host = taurus.Factory('tango').getAuthority().getFullName() self.ui.tangoTree.setModel(host) except Exception as e: taurus.info('Cannot populate Tango Tree: %r', e) # Connections self.ui.applyBT.clicked.connect(self.onApply) self.ui.reloadBT.clicked.connect(self.onReload) self.ui.cancelBT.clicked.connect(self.close) self.ui.tangoTree.addModels.connect(self.onModelsAdded) self.ui.curvesTable.customContextMenuRequested.connect( self.onTableContextMenu)
def export_devices_from_application(*args): print('export_devices:' + str(args)) exported = 'ui_exported_devices.txt' exported2 = 'ui_exported_attributes.txt' assert args, 'Usage: simulation.py list filename.py main_method_name' filename, method_name = args[0], (args[1:] or [''])[0] args = args[3:] main_thread = threading.Thread(target=run_app, args=(filename, method_name, args)) print('*' * 80) print( 'app ready to launch, type the seconds to wait before exporting your devices' ) print('*' * 80) try: timeout = raw_input('enter timeout (in seconds): ') except: traceback.print_exc() timeout = 30. timeout = int(timeout) main_thread.setDaemon(True) main_thread.start() for i in range(timeout): print(timeout - i) time.sleep(1.) import taurus factory = taurus.Factory() print('*' * 80) for f, l in [(exported, factory.getExistingDevices()), (exported2, factory.getExistingAttributes())]: print('list saved to %s' % f) f = open(f, 'w') txt = '\n'.join(l.keys()) f.write(txt) print(txt) f.close() print('*' * 80) return (exported)
def __init__(self, name=None, parent=None): if name is None: t_f = taurus.Factory('tango') t_default_authority = t_f.get_default_tango_host() if t_default_authority is None: pytango_host = PyTango.ApiUtil.get_env_var("TANGO_HOST") host, port = pytango_host.split(':') t_default_authority = "//{0}:{1}".format( socket.getfqdn(host), port) name = '%s:%s' % (self._scheme, t_default_authority) TaurusAuthority.__init__(self, name, parent) v = TangoArchivingAuthorityNameValidator() groups = v.getUriGroups(name) if groups is None: raise TaurusException('Invalid name %s' % name) host = groups.get('host') port = groups.get('port') try: self._tangodb = PyTango.Database(host, port) except PyTango.DevFailed: raise TaurusException('Can not connect to the tango database')
def setUp(self): self.factory = taurus.Factory()
return def recordDataReceived(self, s, t, v): if not self.initDone: print "recordDataRec, return" return if not hasattr(self, "plot"): # # here we would like to execute addPlot() # #try: # self.tan = self.win.addPlot( row=0, col=0) # *** #except Exception, e: # print "recordDataReceived: caught exception" # print repr( e) # return self.tan.showGrid(x=True, y=True) self.tan.enableAutoRange(x=True, y=True) self.plot = self.tan.plot(pen=(0, 0, 255)) return self.plot.setData(self.x[:self.i], self.t[:self.i]) self.i += 1 if self.i == len(self.x): self.i = 0 factory = taurus.Factory() factory.registerDeviceClass('Door', demoDoor)
def init(self, *args, **kwargs): """Singleton instance initialization.""" name = self.__class__.__name__ Logger.__init__(self, name) TaurusFactory.__init__(self) self.scheme = "h5file" def getAuthorityNameValidator(self): """Return H5fileDatabaseNameValidator""" from . import h5filevalidator return h5filevalidator.H5fileAuthorityNameValidator() def getDeviceNameValidator(self): """Return H5fileDeviceNameValidator""" from . import h5filevalidator return h5filevalidator.H5fileDeviceNameValidator() def getAttributeNameValidator(self): """Return H5fileAttributeNameValidator""" from . import h5filevalidator return h5filevalidator.H5fileAttributeNameValidator() ## Just for test purpose if __name__ == "__main__": import taurus f = taurus.Factory('h5file') f2 = H5fileFactory() print(f2.scheme)
def registerExtensions(): factory = taurus.Factory() factory.registerDeviceClass("PyDsExp", TaurusPyDsExp)
def prepare_taurus(options, args, tango_args): # make sure the polling is not active factory = taurus.Factory() factory.disablePolling()
def _get_default_model(self): """Reimplemented from TaurusModelSelectorItem""" if self._default_model is None: f = taurus.Factory('tango') self._default_model = f.getAuthority().getFullName() return self._default_model
def setModel(self, model, pixmap=None): model, modelclass, raw = str(model).strip(), '', model if model: model = model and model.split()[0] or '' modelclass = taurus.Factory().findObjectClass(model) self.trace('In TaurusDevicePanel.setModel(%s(%s),%s)' % (raw, modelclass, pixmap)) if model == self.getModel(): return elif raw is None or not model or not modelclass: if self.getModel(): self.detach() return elif issubclass(modelclass, TaurusAttribute): # if model.lower().endswith('/state'): model = model.rsplit('/', 1)[0] # TODO: Tango-centric elif not issubclass(modelclass, TaurusDevice): self.warning('TaurusDevicePanel accepts only Device models') return try: taurus.Device(model).ping() # TODO: Tango-centric if self.getModel(): self.detach( ) # Do not dettach previous model before pinging the new one (fail message will be shown at except: clause) TaurusWidget.setModel(self, model) self.setWindowTitle(str(model).upper()) model = self.getModel() self._label.setText(model.upper()) font = self._label.font() font.setPointSize(15) self._label.setFont(font) if pixmap is None and self.getIconMap(): for k, v in self.getIconMap().items(): if searchCl(k, model): pixmap = v if pixmap is not None: # print 'Pixmap is %s'%pixmap qpixmap = Qt.QPixmap(pixmap) if qpixmap.height() > .9 * IMAGE_SIZE[1]: qpixmap = qpixmap.scaledToHeight(.9 * IMAGE_SIZE[1]) if qpixmap.width() > .9 * IMAGE_SIZE[0]: qpixmap = qpixmap.scaledToWidth(.9 * IMAGE_SIZE[0]) else: logo = getattr(tauruscustomsettings, 'ORGANIZATION_LOGO', "logos:taurus.png") qpixmap = getCachedPixmap(logo) self._image.setPixmap(qpixmap) if hasattr(self, '_statelabel'): self._statelabel.setModel(model + '/state') # TODO: Tango-centric self._status.setModel(model + '/status') # TODO: Tango-centric try: self._attrsframe.clear() filters = get_regexp_dict(TaurusDevicePanel._attribute_filter, model, ['.*']) if hasattr(filters, 'keys'): filters = filters.items() # Dictionary! if filters and isinstance(filters[0], (list, tuple)): # Mapping self._attrs = [] for tab, attrs in filters: self._attrs.append( self.get_attrs_form(device=model, filters=attrs, parent=self)) self._attrsframe.addTab(self._attrs[-1], tab) else: if self._attrs and isinstance(self._attrs, list): self._attrs = self._attrs[0] self._attrs = self.get_attrs_form(device=model, form=self._attrs, filters=filters, parent=self) if self._attrs: self._attrsframe.addTab(self._attrs, 'Attributes') if not TaurusDevicePanel.READ_ONLY: self._comms = self.get_comms_form(model, self._comms, self) if self._comms: self._attrsframe.addTab(self._comms, 'Commands') if SPLIT_SIZES: self._splitter.setSizes(SPLIT_SIZES) except: self.warning(traceback.format_exc()) qmsg = Qt.QMessageBox(Qt.QMessageBox.Critical, '%s Error' % model, '%s not available' % model, Qt.QMessageBox.Ok, self) qmsg.setDetailedText(traceback.format_exc()) qmsg.show() except: self.warning(traceback.format_exc()) qmsg = Qt.QMessageBox(Qt.QMessageBox.Critical, '%s Error' % model, '%s not available' % model, Qt.QMessageBox.Ok, self) qmsg.show() self.setWindowTitle(self.getModel()) return
def setUp(self): self.f = taurus.Factory('eval')
## ############################################################################# """Test for taurus.core.evaluation.test.test_evalvalidator...""" __docformat__ = 'restructuredtext' import taurus from taurus.external import unittest from taurus.core.test import (valid, invalid, names, AbstractNameValidatorTestCase) from taurus.core.evaluation.evalvalidator import ( EvaluationAuthorityNameValidator, EvaluationDeviceNameValidator, EvaluationAttributeNameValidator) try: authority = taurus.Factory('tango').getAuthority() default_tango_authority = authority.getSimpleName() reason = None except: default_tango_authority = None reason = "Tango scheme is not available" #========================================================================= # Tests for Eval Authority name validation #========================================================================= @valid(name='eval://localhost') @invalid(name='eval://*****:*****@invalid(name='eval://user@foo:10000') @invalid(name='eval://user@localhost') @invalid(name='eval://localhost/')
def tearDown(self): f = taurus.Factory('res') f.clear()
def setUp(self): unittest.TestCase.setUp(self) f = taurus.Factory('res') f.clear() # make sure we use a clean res factory f.loadResource(self.res_map)