def test_ValueRefEnabled(self, elements=["_test_2d_1_1", "_test_2d_1_2", "_test_ct_1_3", "_test_mt_1_3/position"]): mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) try: mg = Device(mg_name) # Check initial state of all kind of channels, nonexistent # channels for the feature return None as result. enabled = mg.getValueRefEnabled(*elements) expected = [False, False, None, None] self._assertMultipleResults(enabled, elements, expected) # Check if the nonexistent channels raise error if trying to set with self.assertRaises(Exception): mg.setValueRefEnabled(True, *elements[-2]) with self.assertRaises(Exception): mg.setValueRefEnabled(True, *elements[-1]) # Redefine elements to ony use existing values elements = ["_test_2d_1_1", "_test_2d_1_2"] # Test every possible combination of setting values # Check that changing one channel doesn't affect the other mg.setValueRefEnabled(True, *elements) enabled = mg.getValueRefEnabled(*elements) self._assertResult(enabled, elements, True) mg.setValueRefEnabled(False, elements[0]) result = mg.getValueRefEnabled(*elements) expected = [True] * len(elements) expected[0] = False self._assertMultipleResults(result, elements, expected) mg.setValueRefEnabled(True, *elements) enabled = mg.getValueRefEnabled(*elements) self._assertResult(enabled, elements, True) # Set values using the controller instead of channels mg.setValueRefEnabled(True, "_test_2d_ctrl_1") enabled = mg.getValueRefEnabled(*elements) self._assertResult(enabled, elements, True) # Get values by controller mg.setValueRefEnabled(False, *elements) enabled = mg.getValueRefEnabled("_test_2d_ctrl_1") self._assertResult(enabled, elements, False) # Check ret_full_name v = TangoDeviceNameValidator() full_names = [v.getNames(element)[0] for element in elements] enabled = mg.getValueRefEnabled(*full_names) self._assertResult(enabled, elements, False) mg.setValueRefEnabled(True, *full_names) enabled = mg.getValueRefEnabled(*elements, ret_full_name=True) self._assertResult(enabled, full_names, True) finally: mg.cleanUp() if os.name != "nt": self.pool.DeleteElement(mg_name)
def test_ValueRefPattern(self, elements=[ "_test_2d_1_1", "_test_2d_1_2", "_test_ct_1_3", "_test_mt_1_3/position" ]): mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) try: mg = Device(mg_name) # Check initial state of all kind of channels, nonexistent # channels for the feature return None as result. pattern = mg.getValueRefPattern(*elements) expected = ['', '', None, None] self._assertMultipleResults(pattern, elements, expected) # Check if the nonexistent channels raise error if trying to set with self.assertRaises(Exception): mg.setValueRefPattern('/tmp/test_foo.txt', *elements[-2]) with self.assertRaises(Exception): mg.setValueRefPattern('/tmp/test_foo.txt', *elements[-1]) # Redefine elements to ony use existing values elements = ["_test_2d_1_1", "_test_2d_1_2"] # Test every possible combination of setting values # Check that changing one channel doesn't affect the other mg.setValueRefPattern('/tmp/test_foo.txt', *elements) pattern = mg.getValueRefPattern(*elements) self._assertResult(pattern, elements, '/tmp/test_foo.txt') # Set values using the controller instead of channels mg.setValueRefPattern('/tmp/test_foo2.txt', "_test_2d_ctrl_1") pattern = mg.getValueRefPattern(*elements) self._assertResult(pattern, elements, '/tmp/test_foo2.txt') # Get values by controller mg.setValueRefPattern('/tmp/test_foo.txt', *elements) pattern = mg.getValueRefPattern("_test_2d_ctrl_1") self._assertResult(pattern, elements, '/tmp/test_foo.txt') # Check ret_full_name v = TangoDeviceNameValidator() full_names = [v.getNames(element)[0] for element in elements] pattern = mg.getValueRefPattern(*full_names) self._assertResult(pattern, elements, '/tmp/test_foo.txt') mg.setValueRefPattern('/tmp/test_foo2.txt', *full_names) pattern = mg.getValueRefPattern(*elements, ret_full_name=True) self._assertResult(pattern, full_names, '/tmp/test_foo2.txt') finally: mg.cleanUp() self.pool.DeleteElement(mg_name)
def test_Synchronizer(self, elements=[ "_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_1", "_test_mt_1_3/position" ]): mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) try: mg = Device(mg_name) result = mg.getSynchronizer() expected = ['software', 'software', 'software', 'software', None] self._assertMultipleResults(result, elements, expected) with self.assertRaises(Exception): mg.setSynchronizer('_test_tg_1_2', "_test_mt_1_3/position") mg.setSynchronizer('_test_tg_1_2', "_test_ct_ctrl_1", "_test_2d_ctrl_1") expected = [ '_test_tg_1_2', '_test_tg_1_2', '_test_tg_1_2', '_test_tg_1_2', None ] result = mg.getSynchronizer() self._assertMultipleResults(result, elements, expected) mg.setSynchronizer('software', "_test_ct_ctrl_1", "_test_2d_ctrl_1") result = mg.getSynchronizer() expected = ['software', 'software', 'software', 'software', None] self._assertMultipleResults(result, elements, expected) with self.assertRaises(Exception): mg.setSynchronizer('asdf', "_test_ct_ctrl_1", "_test_2d_ctrl_1") # Check ret_full_name v = TangoDeviceNameValidator() counters = [ "_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", '_test_2d_1_1' ] full_names = [v.getNames(counter)[0] for counter in counters] mg.setSynchronizer('_test_tg_1_2', "_test_ct_ctrl_1", "_test_2d_ctrl_1") result = mg.getSynchronizer(*counters, ret_full_name=True) self._assertResult(result, full_names, '_test_tg_1_2') finally: mg.cleanUp() self.pool.DeleteElement(mg_name)
def test_Synchronization(self, elements=["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_1", "_test_mt_1_3/position"]): mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) try: mg = Device(mg_name) result = mg.getSynchronization() expected = [AcqSynchType.Trigger, AcqSynchType.Trigger, AcqSynchType.Trigger, AcqSynchType.Trigger, None] self._assertMultipleResults(result, elements, expected) # TODO: maybe we should raise an exception here? # with self.assertRaises(Exception): # mg.setSynchronization(AcqSynchType.Trigger, # "_test_mt_1_3/position") mg.setSynchronization(AcqSynchType.Gate, "_test_ct_ctrl_1", "_test_2d_ctrl_1") expected = [AcqSynchType.Gate, AcqSynchType.Gate, AcqSynchType.Gate, AcqSynchType.Gate, None] result = mg.getSynchronization() self._assertMultipleResults(result, elements, expected) mg.setSynchronization(AcqSynchType.Start, "_test_ct_ctrl_1", "_test_2d_ctrl_1") result = mg.getSynchronization() expected = [AcqSynchType.Start, AcqSynchType.Start, AcqSynchType.Start, AcqSynchType.Start, None] self._assertMultipleResults(result, elements, expected) with self.assertRaises(Exception): mg.setSynchronization('asdf', "_test_ct_ctrl_1", "_test_2d_ctrl_1") # Check ret_full_name v = TangoDeviceNameValidator() counters = ["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", '_test_2d_1_1'] full_names = [v.getNames(counter)[0] for counter in counters] mg.setSynchronization(AcqSynchType.Trigger, "_test_ct_ctrl_1", "_test_2d_ctrl_1") result = mg.getSynchronization(*counters, ret_full_name=True) self._assertResult(result, full_names, AcqSynchType.Trigger) finally: mg.cleanUp() if os.name != "nt": self.pool.DeleteElement(mg_name)
def test_PlotType(self, elements=[ "_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_3", "_test_mt_1_3/position" ]): mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) try: mg = Device(mg_name) plottype = mg.getPlotType() self._assertResult(plottype, elements, 0) mg.setPlotType("Image", elements[0]) mg.setPlotType("Spectrum", elements[1]) mg.setPlotType("No", elements[2]) mg.setPlotType("Image", elements[3]) mg.setPlotType("Image", elements[4]) plottype = mg.getPlotType() expected_values = [2, 1, 0, 2, 2] self._assertMultipleResults(plottype, elements, expected_values) with self.assertRaises(ValueError): mg.setPlotType("asdf", elements[2]) # Redefine elements elements = ["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3"] # Set values using the controller instead of channels mg.setPlotType("Image", "_test_ct_ctrl_1") plottype = mg.getPlotType(*elements) self._assertResult(plottype, elements, 2) # Get values by controller mg.setPlotType("Spectrum", *elements) plottype = mg.getPlotType("_test_ct_ctrl_1") self._assertResult(plottype, elements, 1) # Check ret_full_name v = TangoDeviceNameValidator() full_names = [v.getNames(element)[0] for element in elements] plottype = mg.getPlotType(*full_names) self._assertResult(plottype, elements, 1) mg.setPlotType("Image", *full_names) plottype = mg.getPlotType(*elements, ret_full_name=True) self._assertResult(plottype, full_names, 2) finally: mg.cleanUp() self.pool.DeleteElement(mg_name)
def __init__(self, event_callback, unsubscribe_callback, period=0.5): QtCore.QThread.__init__(self) self.listeners = CaselessDict() self.inverse_listeners = {} self.event_callback = event_callback self.unsubscribe_callback = unsubscribe_callback self.period = period self._attributes = None self._config = CaselessDict() self._last_event = TTLDict(default_ttl=10) self.attribute_validator = TangoAttributeNameValidator() self.device_validator = TangoDeviceNameValidator() self.eval_validator = EvaluationAttributeNameValidator() self.lock = Lock() self.stopped = Event()
def test_Monitor(self, elements=[ "_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_1", '_test_2d_1_2', "_test_mt_1_3/position" ]): mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) try: mg = Device(mg_name) with self.assertRaises(Exception): mg.setMonitor("_test_mt_1_3/position") mg.setMonitor('_test_2d_1_2') mg.setMonitor("_test_ct_1_3") expected = [ "_test_ct_1_3", "_test_ct_1_3", "_test_ct_1_3", "_test_2d_1_2", '_test_2d_1_2', None ] result = mg.getMonitor() self._assertMultipleResults(result, elements, expected) expected = ["_test_ct_1_3", '_test_2d_1_2', None] result = mg.getMonitor(ret_by_ctrl=True) ctrls = ['_test_ct_ctrl_1', '_test_2d_ctrl_1', '__tango__'] self._assertMultipleResults(result, ctrls, expected) # Check ret_full_name v = TangoDeviceNameValidator() counters = [ "_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", '_test_2d_1_1', '_test_2d_1_2' ] full_names = [v.getNames(counter)[0] for counter in counters] mg.setMonitor(v.getNames('_test_ct_1_1')[0]) mg.setMonitor(v.getNames('_test_2d_1_2')[0]) result = mg.getMonitor(*counters, ret_full_name=True) expected = [ "_test_ct_1_1", "_test_ct_1_1", "_test_ct_1_1", "_test_2d_1_2", '_test_2d_1_2' ] self._assertMultipleResults(result, full_names, expected) finally: mg.cleanUp() self.pool.DeleteElement(mg_name)
def _to_fqdn(name, logger=None): """Helper to convert name into a FQDN URI reference. Works for devices and attributes. Prior to sardana 2.4.0 Pool element references were using not unique full names e.g. pc255:10000/motor/motctrl20/1. This helper converts them into FQDN URI references e.g. tango://pc255.cells.es:10000/motor/motctrl20/1. It is similarly solved for attribute names. """ full_name = name # try to use Taurus 4 to retrieve FQDN URI name try: from taurus.core.tango.tangovalidator import TangoDeviceNameValidator try: full_name, _, _ = TangoDeviceNameValidator().getNames(name) # it is not a device try as an attribute except Exception: from taurus.core.tango.tangovalidator import \ TangoAttributeNameValidator full_name, _, _ = TangoAttributeNameValidator().getNames(name) # if Taurus3 in use just continue except ImportError: pass if full_name != name and logger: msg = ("PQDN full name is deprecated in favor of FQDN full name. " "Re-apply pre-scan snapshot configuration in order to " "upgrade.") logger.warning(msg) return full_name
def test_Timer(self, elements=[ "_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_mt_1_3/position" ]): mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) try: mg = Device(mg_name) result = mg.getTimer("_test_mt_1_3/position") with self.assertRaises(Exception): mg.setTimer("_test_mt_1_3/position") self._assertResult(result, ["_test_mt_1_3/position"], None) mg.setTimer('_test_ct_1_3') result = mg.getTimer(*elements) expected = ['_test_ct_1_3', '_test_ct_1_3', '_test_ct_1_3', None] self._assertMultipleResults(result, elements, expected) mg.setTimer('_test_ct_1_2') result = mg.getTimer(*elements) expected = ['_test_ct_1_2', '_test_ct_1_2', '_test_ct_1_2', None] self._assertMultipleResults(result, elements, expected) result = mg.getTimer(*elements, ret_by_ctrl=True) self._assertMultipleResults(result, ['_test_ct_ctrl_1', '__tango__'], ['_test_ct_1_2', None]) # Check ret_full_name v = TangoDeviceNameValidator() counters = ["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3"] full_names = [v.getNames(counter)[0] for counter in counters] mg.setTimer(v.getNames('_test_ct_1_1')[0]) result = mg.getTimer() expected = ['_test_ct_1_1', '_test_ct_1_1', '_test_ct_1_1', None] self._assertMultipleResults(result, elements, expected) # TODO ret_full_name gives controler name mg.setTimer("_test_ct_1_2") result = mg.getTimer(*counters, ret_full_name=True) self._assertResult(result, full_names, "_test_ct_1_2") finally: mg.cleanUp() self.pool.DeleteElement(mg_name)
def _get_full_name(device_proxy, logger=None): """Obtain Sardana full name as it is used by the server.""" db = PyTango.Database() if db.get_from_env_var(): db_name = PyTango.ApiUtil.get_env_var("TANGO_HOST") else: host = device_proxy.get_db_host() # this is FQDN port = device_proxy.get_db_port() db_name = host + ":" + port full_name = "//" + db_name + "/" + device_proxy.name() full_name, _, _ = TangoDeviceNameValidator().getNames(full_name) return full_name
def _to_fqdn(name, logger=None): full_name = name # try to use Taurus 4 to retrieve FQDN try: from taurus.core.tango.tangovalidator import TangoDeviceNameValidator full_name, _, _ = TangoDeviceNameValidator().getNames(name) # if Taurus3 in use just continue except ImportError: pass if full_name != name and logger: msg = ("PQDN full name is deprecated in favor of FQDN full name." " Re-apply configuration in order to upgrade.") logger.warning(msg) return full_name
def __init__(self, event_callback, unsubscribe_callback, period=0.5): QtCore.QThread.__init__(self) self.listeners = CaselessDict() self.inverse_listeners = {} self.event_callback = event_callback self.unsubscribe_callback = unsubscribe_callback self.period = period self._attributes = CaselessList() self._config = CaselessDict() self._last_event = TTLDict(default_ttl=10) self.attribute_validator = TangoAttributeNameValidator() self.device_validator = TangoDeviceNameValidator() self.eval_validator = EvaluationAttributeNameValidator() self.lock = Lock() self.stopped = Event()
def _get_full_name(device_proxy, logger=None): """Obtain Sardana full name as it is used by the server.""" db = PyTango.Database() if db.get_from_env_var(): db_name = PyTango.ApiUtil.get_env_var("TANGO_HOST") else: host = device_proxy.get_db_host() # this is FQDN port = device_proxy.get_db_port() db_name = host + ":" + port full_name = db_name + "/" + device_proxy.name() # try to use Taurus 4 to retrieve FQDN try: from taurus.core.tango.tangovalidator import TangoDeviceNameValidator full_name, _, _ = TangoDeviceNameValidator().getNames(full_name) # if Taurus3 in use just continue except ImportError: pass return full_name
def run(self, var): pars = var.split(".") door_name = None macro_name = None if len(pars) == 1: key = pars[0] elif len(pars) > 1: _, door_name, _ = TangoDeviceNameValidator().getNames(pars[0]) if door_name is None: # first string is a Macro name macro_name = pars[0] if len(pars) == 3: macro_name = pars[1] key = pars[2] else: key = pars[1] env = self.getEnv(key=key, macro_name=macro_name, door_name=door_name) self.output("{:s} = {:s}".format(str(key), str(env)))
class Registry(QtCore.QThread): """ A thread that handles attribute subscriptions. The main purpose of this thread is to offload the setting up and tearing down of subscriptions from the main UI thread, to make the operation "asynchronous". We don't want the UI to lock up briefly every time we do this (which may be very often in the case of a large, zoomable synoptic). """ def __init__(self, event_callback, unsubscribe_callback, period=0.5): QtCore.QThread.__init__(self) self.listeners = CaselessDict() self.inverse_listeners = {} self.event_callback = event_callback self.unsubscribe_callback = unsubscribe_callback self.period = period self._attributes = None self._config = CaselessDict() self._last_event = TTLDict(default_ttl=10) self.attribute_validator = TangoAttributeNameValidator() self.device_validator = TangoDeviceNameValidator() self.eval_validator = EvaluationAttributeNameValidator() self.lock = Lock() self.stopped = Event() def run(self): "A simple loop checking for changes to the attribute list" # "batching" the updates should be more efficient than # reacting immediately, especially when listeners can come and # go quite frequently. while not self.stopped.is_set(): sleep(self.period) if self._attributes is not None: attributes, self._attributes = self._attributes, None with self.lock: self._update(attributes) def subscribe(self, models=[]): """Set the currently subscribed list of models.""" attrs = CaselessDict() for model in models: if self.device_validator.isValid(model): # for convenience, we subscribe to State for any devices attrs[model + "/State"] = True elif (self.attribute_validator.isValid(model) or self.eval_validator.isValid(model)): attrs[model] = True else: print "Invalid Taurus model %s!?" % model self._attributes = attrs def get_value(self, model): evt = self._last_event.get(model) if evt: return evt.attr_value def get_config(self, model): return self._config.get(model) def handle_event(self, evt_src, *args): # lookup the model(s) for this listener and notify them models = self.inverse_listeners.get(evt_src, []) for model in models: self.event_callback(model, evt_src, *args) def _update(self, attributes=CaselessDict()): "Update the subscriptions; add new ones, remove old ones" listeners = set(k.lower() for k in self.listeners.keys()) new_attrs = set(attributes) - set(listeners) old_attrs = set(listeners) - set(attributes) for attr in old_attrs: if self._attributes: # meaning we got a new list of subscriptions, so # no point in continuing with this one. return self._remove_listener(attr) self._last_event.pop(attr, None) for attr in new_attrs: if self._attributes: return try: self._add_listener(attr) except (TypeError, PyTango.DevFailed) as e: print "Failed to setup listener for", attr, e self.unsubscribe_callback(old_attrs) def _add_listener(self, model): try: listener = self.listeners[model] = Attribute(model) # to make loopkups more efficient, we also keep an "inverted" # mapping of listeners->models. But since some models may map # to the *same* listener (e.g. eval expressions), this must # be a one-to-many map. if listener in self.inverse_listeners: self.inverse_listeners[listener][model] = True else: self.inverse_listeners[listener] = CaselessDict([(model, True) ]) listener.addListener(self.handle_event) return listener except (TaurusException, AttributeError) as e: print "Failed to subscribe to model %s! %s" % (model, e) def _remove_listener(self, model): listener = self.listeners.pop(model) models = self.inverse_listeners[listener] models.pop(model) if not models: self.inverse_listeners.pop(listener) listener.removeListener(self.handle_event) def get_listener(self, model): "return the listener for a given model" if model in self.listeners: return self.listeners[model] for attr in self.listeners.values(): if attr.getNormalName().lower() == model.lower(): return attr def stop(self): self.stopped.set() def clear(self): self._attributes.clear() self._last_event.clear() self._update()
class Registry(QtCore.QThread): """ A thread that handles attribute subscriptions. The main purpose of this thread is to offload the setting up and tearing down of subscriptions from the main UI thread, to make the operation "asynchronous". We don't want the UI to lock up briefly every time we do this (which may be very often in the case of a large, zoomable synoptic). """ def __init__(self, event_callback, unsubscribe_callback, period=0.5): QtCore.QThread.__init__(self) self.listeners = CaselessDict() self.inverse_listeners = {} self.event_callback = event_callback self.unsubscribe_callback = unsubscribe_callback self.period = period self._attributes = CaselessList() self._config = CaselessDict() self._last_event = TTLDict(default_ttl=10) self.attribute_validator = TangoAttributeNameValidator() self.device_validator = TangoDeviceNameValidator() self.eval_validator = EvaluationAttributeNameValidator() self.lock = Lock() self.stopped = Event() def run(self): "A simple loop checking for changes to the attribute list" # "batching" the updates should be more efficient than # reacting immediately, especially when listeners can come and # go quite frequently. while not self.stopped.is_set(): sleep(self.period) if self._attributes: attributes, self._attributes = self._attributes, CaselessList() with self.lock: self._update(attributes) def subscribe(self, models=[]): """Set the currently subscribed list of models.""" attrs = CaselessDict() for model in models: if self.device_validator.isValid(model): # for convenience, we subscribe to State for any devices attrs[model + "/State"] = True elif self.attribute_validator.isValid(model) or self.eval_validator.isValid(model): attrs[model] = True else: print "Invalid Taurus model %s!?" % model self._attributes = attrs def get_value(self, model): evt = self._last_event.get(model) if evt: return evt.attr_value def get_config(self, model): return self._config.get(model) def handle_event(self, evt_src, *args): # lookup the model(s) for this listener and notify them models = self.inverse_listeners.get(evt_src, []) for model in models: self.event_callback(model, evt_src, *args) def _update(self, attributes=CaselessDict()): "Update the subscriptions; add new ones, remove old ones" listeners = set(k.lower() for k in self.listeners.keys()) new_attrs = set(attributes) - set(listeners) old_attrs = set(listeners) - set(attributes) for attr in old_attrs: if self._attributes: # meaning we got a new list of subscriptions, so # no point in continuing with this one. return self._remove_listener(attr) self._last_event.pop(attr, None) for attr in new_attrs: if self._attributes: return try: self._add_listener(attr) except PyTango.DevFailed as e: print "Failed to setup listener for", attr, e self.unsubscribe_callback(old_attrs) def _add_listener(self, model): try: listener = self.listeners[model] = Attribute(model) # to make loopkups more efficient, we also keep an "inverted" # mapping of listeners->models. But since some models may map # to the *same* listener (e.g. eval expressions), this must # be a one-to-many map. if listener in self.inverse_listeners: self.inverse_listeners[listener][model] = True else: self.inverse_listeners[listener] = CaselessDict([(model, True)]) listener.addListener(self.handle_event) return listener except AttributeError: print "Failed to subscribe to model %s!" % model def _remove_listener(self, model): listener = self.listeners.pop(model) models = self.inverse_listeners[listener] print models, model models.pop(model) if not models: self.inverse_listeners.pop(listener) listener.removeListener(self.handle_event) def get_listener(self, model): "return the listener for a given model" if model in self.listeners: return self.listeners[model] for attr in self.listeners.values(): if attr.getNormalName().lower() == model.lower(): return attr def stop(self): self.stopped.set() def clear(self): self._attributes.clear() self._last_event.clear() self._update()
def test_PlotAxes(self, elements=[ "_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3", "_test_2d_1_3", "_test_mt_1_3/position" ]): mg_name = str(uuid.uuid1()) argin = [mg_name] + elements self.pool.CreateMeasurementGroup(argin) try: mg = Device(mg_name) mg.setPlotType("Image", elements[0]) mg.setPlotType("Spectrum", elements[1]) mg.setPlotType("No", elements[2]) mg.setPlotType("Image", elements[3]) mg.setPlotType("Image", elements[4]) result = mg.getPlotAxes() self._assertResult(result, elements, []) mg.setPlotAxes(["<idx>", "<idx>"], elements[0]) mg.setPlotAxes(["<mov>"], elements[1]) with self.assertRaises(Exception): mg.setPlotAxes(['<mov>'], elements[2]) mg.setPlotAxes(["<idx>", "<idx>"], elements[3]) mg.setPlotAxes(["<idx>", "<idx>"], elements[4]) result = mg.getPlotAxes() expected_result = [['<idx>', '<idx>'], ['<mov>'], [], ['<idx>', '<idx>'], ['<idx>', '<idx>']] self._assertMultipleResults(result, elements, expected_result) mg.setPlotAxes(["<mov>", "<idx>"], elements[0]) mg.setPlotAxes(["<idx>"], elements[1]) result = mg.getPlotAxes() expected_result = [['<mov>', '<idx>'], ['<idx>'], [], ['<idx>', '<idx>'], ['<idx>', '<idx>']] self._assertMultipleResults(result, elements, expected_result) mg.setPlotAxes(["<mov>", "<mov>"], elements[0]) result = mg.getPlotAxes() expected_result = [['<mov>', '<mov>'], ['<idx>'], [], ['<idx>', '<idx>'], ['<idx>', '<idx>']] self._assertMultipleResults(result, elements, expected_result) with self.assertRaises(RuntimeError): mg.setPlotAxes(["<mov>"], elements[2]) with self.assertRaises(ValueError): mg.setPlotAxes(["<mov>", "<idx>"], elements[1]) with self.assertRaises(ValueError): mg.setPlotAxes(["<mov>"], elements[0]) elements = ["_test_ct_1_1", "_test_ct_1_2", "_test_ct_1_3"] # Set values using the controller instead of channels with self.assertRaises(Exception): mg.setPlotAxes(["<mov>"], "_test_ct_ctrl_1") # TODO get method by controller doesn't give the order # Get values by controller result = mg.getPlotAxes("_test_ct_ctrl_1") expected_result = [['<mov>', '<mov>'], ['<idx>'], []] self._assertMultipleResults(result, elements, expected_result) # Check ret_full_name v = TangoDeviceNameValidator() full_names = [v.getNames(element)[0] for element in elements] result = mg.getPlotAxes(*full_names) expected_result = [['<mov>', '<mov>'], ['<idx>'], []] self._assertMultipleResults(result, elements, expected_result) mg.setPlotAxes(["<idx>", "<idx>"], full_names[0]) mg.setPlotAxes(["<mov>"], full_names[1]) result = mg.getPlotAxes(*elements, ret_full_name=True) expected_result = [['<idx>', '<idx>'], ['<mov>'], []] self._assertMultipleResults(result, full_names, expected_result) finally: mg.cleanUp() self.pool.DeleteElement(mg_name)
def from_name_to_tango(name): try: from taurus.core.tango.tangovalidator import TangoDeviceNameValidator return TangoDeviceNameValidator().getNames(name) except ImportError: return _from_name_to_tango(name)