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)
