def main():
# set the log level to WARNING avoid spamming the CLI while loading
# subcommands
# it will be restored to the desired one first thing in taurus_cmd()
taurus.setLogLevel(taurus.Warning)
# Add subcommands from the taurus_subcommands entry point
for ep in pkg_resources.iter_entry_points('taurus.cli.subcommands'):
try:
subcommand = ep.load()
taurus_cmd.add_command(subcommand)
except Exception as e:
# -----------------------------------------------------------
# Use info instead of warning in case of nonimportable Qwt5
# (e.g. when using py3 or Qt5) to avoid spam
# This special case can be removed when taurus.qt.qtgui.qwt5
# is moved to a separate plugin, since the entry point will
# be registered only if the plugin is installed
if ep.name == 'qwt5':
taurus.info('Cannot add "%s" subcommand to taurus. Reason: %r',
ep.name, e)
continue
# -----------------------------------------------------------
taurus.warning('Cannot add "%s" subcommand to taurus. Reason: %r',
ep.name, e)
# launch the taurus command
taurus_cmd()
def main():
import taurus.qt.qtgui.application
Application = taurus.qt.qtgui.application.TaurusApplication
app = Application.instance()
owns_app = app is None
if owns_app:
app = Application(app_name="Logging demo", app_version="1.0",
org_domain="Taurus", org_name="Taurus community")
taurus.setLogLevel(taurus.Trace)
taurus.disableLogOutput()
w = QLoggingWidget()
taurus.trace("trace message")
taurus.debug("debug message")
taurus.info("Hello world")
taurus.warning("Warning message")
taurus.error("error message")
taurus.critical("critical message")
w.setMinimumSize(1200, 600)
w.show()
app.exec_()
w.stop_logging()
def taurus_cmd(log_level, polling_period, serialization_mode, rconsole_port,
default_formatter):
"""The main taurus command"""
# set log level
taurus.setLogLevel(getattr(taurus, log_level))
# set polling period
if polling_period is not None:
taurus.changeDefaultPollingPeriod(polling_period)
# set serialization mode
if serialization_mode is not None:
from taurus.core.taurusbasetypes import TaurusSerializationMode
m = getattr(TaurusSerializationMode, serialization_mode)
taurus.Manager().setSerializationMode(m)
# enable the remote console port
if rconsole_port is not None:
try:
import rfoo.utils.rconsole
rfoo.utils.rconsole.spawn_server(port=rconsole_port)
taurus.info(("rconsole started. " +
"You can connect to it by typing: rconsole -p %d"),
rconsole_port)
except Exception as e:
taurus.warning("Cannot spawn debugger. Reason: %s", e)
# set the default formatter
if default_formatter is not None:
from taurus import tauruscustomsettings
setattr(tauruscustomsettings, 'DEFAULT_FORMATTER', default_formatter)
def test_expert(self):
CTRL_NAME = "unittestmotctrl01"
MOT_NAME1 = "unittestmot01"
MOT_NAME2 = "unittestmot02"
try:
self.macro_runs(macro_name="defctrl",
macro_params=["DummyMotorController", CTRL_NAME],
wait_timeout=1)
self.macro_runs(macro_name="defm",
macro_params=[MOT_NAME1, CTRL_NAME, "1"],
wait_timeout=1)
self.macro_runs(macro_name="defelem",
macro_params=[MOT_NAME2, CTRL_NAME, "2"],
wait_timeout=1)
# add test of renameelem when bug-471 is fixed
# https://sourceforge.net/p/sardana/tickets/471/
# self.macro_runs(macro_name="renameelem",
# macro_params=[MOT_NAME1, MOT_NAME2],
# wait_timeout=1)
self.macro_runs(macro_name="udefelem",
macro_params=[MOT_NAME1, MOT_NAME2],
wait_timeout=1)
self.macro_runs(macro_name="udefctrl",
macro_params=[CTRL_NAME],
wait_timeout=1)
except Exception, e:
import taurus
taurus.warning("Your system may stay dirty due to an unexpected"
" exception during the test.")
raise e
def register_subcommands():
"""Discover and add subcommands to taurus_cmd"""
# Add subcommands from the taurus_subcommands entry point
for ep in pkg_resources.iter_entry_points("taurus.cli.subcommands"):
try:
subcommand = ep.load()
taurus_cmd.add_command(subcommand)
except Exception as e:
# -----------------------------------------------------------
# Use info instead of warning in case of nonimportable Qwt5
# (e.g. when using py3 or Qt5) to avoid spam
# This special case can be removed when taurus.qt.qtgui.qwt5
# is moved to a separate plugin, since the entry point will
# be registered only if the plugin is installed
if ep.name == "qwt5":
taurus.info(
'Cannot add "%s" subcommand to taurus. Reason: %r',
ep.name,
e,
)
continue
# -----------------------------------------------------------
taurus.warning('Cannot add "%s" subcommand to taurus. Reason: %r',
ep.name, e)
def test_expert(self):
CTRL_NAME = "unittestmotctrl01"
MOT_NAME1 = "unittestmot01"
MOT_NAME2 = "unittestmot02"
try:
self.macro_runs(macro_name="defctrl",
macro_params=["DummyMotorController", CTRL_NAME],
wait_timeout=1)
self.macro_runs(macro_name="defm",
macro_params=[MOT_NAME1, CTRL_NAME, "1"],
wait_timeout=1)
self.macro_runs(macro_name="defelem",
macro_params=[MOT_NAME2, CTRL_NAME, "2"],
wait_timeout=1)
# add test of renameelem when bug-471 is fixed
# https://sourceforge.net/p/sardana/tickets/471/
# self.macro_runs(macro_name="renameelem",
# macro_params=[MOT_NAME1, MOT_NAME2],
# wait_timeout=1)
self.macro_runs(macro_name="udefelem",
macro_params=[MOT_NAME1, MOT_NAME2],
wait_timeout=1)
self.macro_runs(macro_name="udefctrl",
macro_params = [CTRL_NAME],
wait_timeout=1)
except Exception, e:
import taurus
taurus.warning("Your system may stay dirty due to an unexpected"
" exception during the test.")
raise e
def main():
import taurus.qt.qtgui.application
Application = taurus.qt.qtgui.application.TaurusApplication
app = Application.instance()
owns_app = app is None
if owns_app:
app = Application(app_name="Logging demo",
app_version="1.0",
org_domain="Taurus",
org_name="Taurus community")
taurus.setLogLevel(taurus.Trace)
taurus.disableLogOutput()
w = QLoggingWidget()
taurus.trace("trace message")
taurus.debug("debug message")
taurus.info("Hello world")
taurus.warning("Warning message")
taurus.error("error message")
taurus.critical("critical message")
w.setMinimumSize(1200, 600)
w.show()
app.exec_()
w.stop_logging()
def test_expert(self):
CTRL_NAME = "unittestmotctrl01"
MOT_NAME1 = "unittestmot01"
MOT_NAME2 = "unittestmot02"
try:
self.macro_runs(macro_name="defctrl",
macro_params=["DummyMotorController", CTRL_NAME],
wait_timeout=1)
self.macro_runs(macro_name="defelem",
macro_params=[MOT_NAME1, CTRL_NAME, "1"],
wait_timeout=1)
self.macro_runs(macro_name="renameelem",
macro_params=[MOT_NAME1, MOT_NAME2],
wait_timeout=1)
self.macro_runs(macro_name="defm",
macro_params=[MOT_NAME1, CTRL_NAME, "2"],
wait_timeout=1)
self.macro_runs(macro_name="udefelem",
macro_params=[MOT_NAME1, MOT_NAME2],
wait_timeout=1)
self.macro_runs(macro_name="udefctrl",
macro_params=[CTRL_NAME],
wait_timeout=1)
except Exception, e:
import taurus
taurus.warning("Your system may stay dirty due to an unexpected"
" exception during the test.")
raise e
def getUriGroups(self, name, strict=None):
'''returns the named groups dictionary from the URI regexp matching.
If strict is False, it also tries to match against the non-strict regexp
(It logs a warning if it matched only the non-strict alternative)
'''
if strict is None:
strict = getattr(tauruscustomsettings, 'STRICT_MODEL_NAMES', False)
name = makeSchemeExplicit(name, default=self.scheme)
m = self.name_re.match(name)
# if it is strictly valid, return the groups
if m is not None:
ret = m.groupdict()
ret['__STRICT__'] = True
return ret
# if we are strict (or no less-strict pattern is defined) return None
if strict or self.nonStrictName_re is None:
return None
# If a less-strict pattern is defined, use it, but warn if it works
m = self.nonStrictName_re.match(name)
if m is None:
return None
else:
from taurus import warning
msg = ('Model name "%s" is supported but not strictly valid. \n' +
'It is STRONGLY recommended that you change it to \n' +
'strictly follow %s scheme syntax') % (name, self.scheme)
warning(msg)
ret = m.groupdict()
ret['__STRICT__'] = False
return ret
def _isValidAtLevel(self, name, matchLevel=None):
# matchLevel is a tango-centric deprecated argument of isValid. Warn.
msg = ('matchLevel is a Tango-centric concept. Avoid it outside ' +
'the tango scheme')
from taurus import warning
warning(msg)
return self.isValid(name)
def _isValidAtLevel(self, name, matchLevel=None):
# matchLevel is a tango-centric deprecated argument of isValid. Warn.
msg = ('matchLevel is a Tango-centric concept. Avoid it outside ' +
'the tango scheme')
from taurus import warning
warning(msg)
return self.isValid(name)
def fqdn_no_alias(hostname):
"""
Normalize hostname so that it is a full name (including domain name).
.. note:: this is similar to socket.getfqdn, but it avoids translating
aliases into their "real" address.
"""
if hostname == "localhost" or "." in hostname:
# optimization: leave localhost or names including domain as they are
return hostname
try:
real, aliases, _ = socket.gethostbyname_ex(hostname)
except (socket.gaierror, socket.herror) as e:
# return the given hostname in case of error
return hostname
if aliases:
if hostname == real or hostname in aliases:
# in some corner cases (e.g. when defining several aliases in a
# hosts file), the hostname may be one of the aliases.
return hostname
# return alias if it exists
if len(aliases) > 1:
# warn in the (unusual) case that there is more than 1 alias
warning("fqdn_no_alias: %s has %d aliases. Using the first one",
hostname, len(aliases))
return aliases[0]
else:
# if there are no aliases, return real
return real
def test_expert(self):
CTRL_NAME = "unittestmotctrl01"
MOT_NAME1 = "unittestmot01"
MOT_NAME2 = "unittestmot02"
try:
self.macro_runs(macro_name="defctrl",
macro_params=["DummyMotorController", CTRL_NAME],
wait_timeout=1)
self.macro_runs(macro_name="defelem",
macro_params=[MOT_NAME1, CTRL_NAME, "1"],
wait_timeout=1)
self.macro_runs(macro_name="renameelem",
macro_params=[MOT_NAME1, MOT_NAME2],
wait_timeout=1)
self.macro_runs(macro_name="defm",
macro_params=[MOT_NAME1, CTRL_NAME, "2"],
wait_timeout=1)
self.macro_runs(macro_name="udefelem",
macro_params=[MOT_NAME1, MOT_NAME2],
wait_timeout=1)
self.macro_runs(macro_name="udefctrl",
macro_params = [CTRL_NAME],
wait_timeout=1)
except Exception, e:
import taurus
taurus.warning("Your system may stay dirty due to an unexpected"
" exception during the test.")
raise e
def getUriGroups(self, name, strict=None):
'''returns the named groups dictionary from the URI regexp matching.
If strict is False, it also tries to match against the non-strict regexp
(It logs a warning if it matched only the non-strict alternative)
'''
if strict is None:
strict = getattr(tauruscustomsettings, 'STRICT_MODEL_NAMES', False)
name = makeSchemeExplicit(name, default=self.scheme)
m = self.name_re.match(name)
# if it is strictly valid, return the groups
if m is not None:
ret = m.groupdict()
ret['__STRICT__'] = True
return ret
# if we are strict (or no less-strict pattern is defined) return None
if strict or self.nonStrictName_re is None:
return None
# If a less-strict pattern is defined, use it, but warn if it works
m = self.nonStrictName_re.match(name)
if m is None:
return None
else:
from taurus import warning
msg = ('Model name "%s" is supported but not strictly valid. \n' +
'It is STRONGLY recommended that you change it to \n' +
'strictly follow %s scheme syntax') % (name, self.scheme)
warning(msg)
ret = m.groupdict()
ret['__STRICT__'] = False
return ret
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 unit_from_tango(unit):
if unit == PyTango.constants.UnitNotSpec:
unit = None
try:
return UR.parse_units(unit)
except UndefinedUnitError:
# TODO: Maybe we could dynamically register the unit in the UR
from taurus import warning
warning('Unknown unit "%s (will be treated as dimensionless)"', unit)
return UR.parse_units(None)
def unit_from_tango(unit):
if unit == PyTango.constants.UnitNotSpec:
unit = None
try:
return UR.parse_units(unit)
except UndefinedUnitError:
# TODO: Maybe we could dynamically register the unit in the UR
from taurus import warning
warning('Unknown unit "%s (will be treated as dimensionless)"', unit)
return UR.parse_units(None)
def plot_cmd(models, config_file, x_axis_mode, demo, window_name, use_alt,
ls_alt):
"""Shows a plot for the given models"""
if ls_alt:
_print_alts(EP_GROUP_PLOT)
sys.exit(0)
if use_alt is None:
use_alt = getattr(_ts, "PLOT_ALT", ".*")
try:
TPlot, epname = _load_class_from_group(EP_GROUP_PLOT,
include=[use_alt])
except:
_print_alts(EP_GROUP_PLOT)
sys.exit(1)
app = TaurusApplication(app_name="taurusplot({})".format(epname))
w = TPlot()
w.setWindowTitle(window_name)
if demo:
models = list(models)
models.extend(["eval:rand(100)", "eval:0.5*sqrt(arange(100))"])
try:
w.setXAxisMode(x_axis_mode)
except Exception as e:
warning(
'Could not set X axis mode to "%s" on %s plot. Reason: "%s"',
x_axis_mode,
epname,
e,
)
sys.exit(1)
if config_file is not None:
try:
w.loadConfigFile(config_file)
except Exception as e:
warning(
'Could not load config file "%s" on %s plot. Reason: "%s"',
config_file,
epname,
e,
)
sys.exit(1)
if models:
w.setModel(models)
w.show()
sys.exit(app.exec_())
def __setTabItemModel(self):
w = self.currentWidget()
c = self.cursor()
try:
if not w.model:
self.setCursor(QtCore.Qt.WaitCursor)
w.setModel(w.default_model)
except Exception as e:
taurus.warning('Problem setting up selector: %r', e)
finally:
self.setCursor(c)
def test_meas(self):
MNTGRP_NAME = "unittestmntgrp01"
try:
self.macro_runs(macro_name="defmeas",
macro_params=[MNTGRP_NAME, CT_NAME1, CT_NAME2])
self.macro_runs(macro_name="udefmeas", macro_params=[MNTGRP_NAME])
except Exception, e:
import taurus
taurus.warning("Your system may stay dirty due to an unexpected"
" exception during the test.")
raise e
def __getattr__(self, member):
try:
mod = self.ep.load()
# Replace lazy module with actual module for package
setattr(sys.modules[self.__package__], self.__name__, mod)
# Replace lazy module with actual module in sys.modules
modname = "%s.%s" % (self.__package__, self.__name__)
sys.modules[modname] = mod
except Exception as e:
warning('Could not load plugin "%s". Reason: %s', self.ep.name, e)
return None
return getattr(mod, member)
def test_meas(self):
MNTGRP_NAME = "unittestmntgrp01"
try:
self.macro_runs(macro_name="defmeas",
macro_params=[MNTGRP_NAME, CT_NAME1, CT_NAME2])
self.macro_runs(macro_name="udefmeas",
macro_params=[MNTGRP_NAME])
except Exception, e:
import taurus
taurus.warning("Your system may stay dirty due to an unexpected"
" exception during the test.")
raise e
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_factory.set_default_tango_host(options.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 unit_from_tango(unit):
from taurus import deprecated
deprecated(dep='unit_from_tango', rel='4.0.4', alt="pint's parse_units")
if unit == PyTango.constants.UnitNotSpec:
unit = None
try:
return UR.parse_units(unit)
except (UndefinedUnitError, UnicodeDecodeError):
# TODO: Maybe we could dynamically register the unit in the UR
from taurus import warning
warning('Unknown unit "%s (will be treated as unitless)"', unit)
return UR.parse_units(None)
def getParams(self, name):
# deprecation warning
msg = ('%s.getParams() is deprecated. Use getUriGroups() instead.' %
self.__class__.__name__)
from taurus import warning
warning(msg)
# support old group names
groups = self.getUriGroups(name, strict=False)
if groups is None:
return None
groups = dict(groups) # copy, just in case
groups['devicename'] = groups.get('devname')
groups['devalias'] = groups.get('_devalias')
groups['attributename'] = groups.get('_shortattrname')
groups['configparam'] = groups.get('fragment')
return groups
def getParams(self, name):
# deprecation warning
msg = ('%s.getParams() is deprecated. Use getUriGroups() instead.' %
self.__class__.__name__)
from taurus import warning
warning(msg)
# support old group names
groups = self.getUriGroups(name, strict=False)
if groups is None:
return None
groups = dict(groups) # copy, just in case
groups['devicename'] = groups.get('devname')
groups['devalias'] = groups.get('_devalias')
groups['attributename'] = groups.get('_shortattrname')
groups['configparam'] = groups.get('fragment')
return groups
def run(self):
try:
import tango
except ImportError:
Worker.run(self)
# Tango is not thread safe when using threading.Thread. One must
# use omni threads instead. This was confirmed for parallel
# event subscriptions in PyTango#307. Use EnsureOmniThread introduced
# in PyTango#327 whenever available.
else:
if hasattr(tango, "EnsureOmniThread"):
with tango.EnsureOmniThread():
Worker.run(self)
else:
import taurus
taurus.warning("Your Sardana system is affected by bug "
"tango-controls/pytango#307. Please use "
"PyTango with tango-controls/pytango#327.")
Worker.run(self)
def __init__(self, parent=None):
Qt.QTabWidget.__init__(self, parent=parent)
self.currentChanged.connect(self.__setTabItemModel)
# ---------------------------------------------------------------------
# Note: this is an experimental feature
# It may be removed or changed in future releases
# Discover the taurus.modelselector plugins
ep_group_name = 'taurus.model_selector.items'
for ep in pkg_resources.iter_entry_points(ep_group_name):
try:
ms_class = ep.load()
ms_item = ms_class(parent=self)
self.__addItem(ms_item, ep.name)
except Exception as e:
err = 'Invalid TaurusModelSelectorItem plugin: {}\n{}'.format(
ep.module_name, e)
taurus.warning(err)
def getElements(elem_type="all", fallback_name="element_not_defined",
fallback_elements_len=5):
if fallback_name is None:
fallback_name = elem_type + "_not_defined"
try:
elements = SarDemoEnv().getElements(elem_type)
except RuntimeError:
import taurus
from sardana import sardanacustomsettings
door_name = getattr(sardanacustomsettings, 'UNITTEST_DOOR_NAME',
'UNDEFINED')
taurus.warning("The door %s is not running. " % (door_name) +
"Ignore this message if you are building the documentation.")
elements = [fallback_name] * fallback_elements_len
except Exception, e:
import taurus
taurus.debug(e)
taurus.warning("It was not possible to retrieve the element. " +
"Ignore this message if you are building the documentation.")
elements = [fallback_name] * fallback_elements_len
def getElements(elem_type="all",
fallback_name="element_not_defined",
fallback_elements_len=5):
if fallback_name is None:
fallback_name = elem_type + "_not_defined"
try:
elements = SarDemoEnv().getElements(elem_type)
except RuntimeError:
import taurus
from sardana import sardanacustomsettings
door_name = getattr(sardanacustomsettings, 'UNITTEST_DOOR_NAME',
'UNDEFINED')
taurus.warning(
"The door %s is not running. " % (door_name) +
"Ignore this message if you are building the documentation.")
elements = [fallback_name] * fallback_elements_len
except Exception, e:
import taurus
taurus.debug(e)
taurus.warning(
"It was not possible to retrieve the element. " +
"Ignore this message if you are building the documentation.")
elements = [fallback_name] * fallback_elements_len
def get_thread_pool():
"""Returns the global pool of threads for Sardana
:return: the global pool of threads object
:rtype: taurus.core.util.ThreadPool"""
global __thread_pool
global __thread_pool_lock
with __thread_pool_lock:
if __thread_pool is None:
# protect older versions of Taurus (without the worker_cls
# argument) remove it whenever we bump Taurus dependency
try:
__thread_pool = ThreadPool(name="SardanaTP",
Psize=10,
worker_cls=OmniWorker)
except TypeError:
import taurus
taurus.warning("Your Sardana system is affected by bug "
"tango-controls/pytango#307. Please use "
"Taurus with taurus-org/taurus#1081.")
__thread_pool = ThreadPool(name="SardanaTP", Psize=10)
return __thread_pool
def __init__(self, host=None, port=None, parent=None):
if host is None or port is None:
try:
_hp = TangoAuthority.get_default_tango_host()
host, port = _hp.rsplit(':', 1)
except Exception:
from taurus import warning
warning("Error getting default Tango host")
# Set host to fqdn
host = socket.getfqdn(host)
self.dbObj = Database(host, port)
self._dbProxy = None
self._dbCache = None
complete_name = "tango://%s:%s" % (host, port)
self.call__init__(TaurusAuthority, complete_name, parent)
try:
self.get_class_for_device(self.dev_name())
except:
# Ok, old tango database.
self.get_class_for_device = self.__get_class_for_device
def tickValues(self, minVal, maxVal, size):
"""
Reimplemented from PlotItem to adjust to the range and to force
the ticks at "round" positions in the context of time units instead of
rounding in a decimal base
"""
maxMajSteps = int(size // self._pxLabelWidth)
dx = maxVal - minVal
majticks = []
try:
dt1 = datetime.fromtimestamp(minVal)
dt2 = datetime.fromtimestamp(maxVal)
except Exception as e:
from taurus import warning
warning("Invalid range in DateTime axis: %s", e)
return [(dx, [])]
if dx > 63072001: # 3600s*24*(365+366) = 2 years (count leap year)
d = timedelta(days=366)
for y in range(dt1.year + 1, dt2.year + 1):
dt = datetime(year=y, month=1, day=1)
majticks.append(mktime(dt.timetuple()))
elif dx > 5270400: # 3600s*24*61 = 61 days
d = timedelta(days=31)
dt = (
dt1.replace(day=1, hour=0, minute=0, second=0, microsecond=0) +
d)
while dt < dt2:
# make sure that we are on day 1 (even if always sum 31 days)
dt = dt.replace(day=1)
majticks.append(mktime(dt.timetuple()))
dt += d
elif dx > 172800: # 3600s24*2 = 2 days
d = timedelta(days=1)
dt = dt1.replace(hour=0, minute=0, second=0, microsecond=0) + d
while dt < dt2:
majticks.append(mktime(dt.timetuple()))
dt += d
elif dx > 7200: # 3600s*2 = 2hours
d = timedelta(hours=1)
dt = dt1.replace(minute=0, second=0, microsecond=0) + d
while dt < dt2:
majticks.append(mktime(dt.timetuple()))
dt += d
elif dx > 1200: # 60s*20 = 20 minutes
d = timedelta(minutes=10)
dt = (dt1.replace(
minute=(dt1.minute // 10) * 10, second=0, microsecond=0) + d)
while dt < dt2:
majticks.append(mktime(dt.timetuple()))
dt += d
elif dx > 120: # 60s*2 = 2 minutes
d = timedelta(minutes=1)
dt = dt1.replace(second=0, microsecond=0) + d
while dt < dt2:
majticks.append(mktime(dt.timetuple()))
dt += d
elif dx > 20: # 20s
d = timedelta(seconds=10)
dt = dt1.replace(second=(dt1.second // 10) * 10, microsecond=0) + d
while dt < dt2:
majticks.append(mktime(dt.timetuple()))
dt += d
elif dx > 2: # 2s
d = timedelta(seconds=1)
# majticks = list(range(int(minVal), int(maxVal)))
majticks = list(
range(int(numpy.ceil(minVal)), int(numpy.ceil(maxVal))))
else: # <2s , use standard implementation from parent
return AxisItem.tickValues(self, minVal, maxVal, size)
# print("majticks >: ", majticks)
L = len(majticks)
if L > maxMajSteps:
if maxMajSteps == 0:
majticks = []
else:
majticks = majticks[::int(numpy.ceil(float(L) / maxMajSteps))]
# print("majticks <: ", majticks)
# print "----------------------------"
return [(d.total_seconds(), majticks)]
def prepare_logging(options,
args,
tango_args,
start_time=None,
log_messages=None):
taurus.setLogLevel(taurus.Debug)
root = Logger.getRootLog()
# output logger configuration
log_output_level = options.log_level
log_level_map = {
"0": taurus.Critical,
"critical": taurus.Critical,
"1": taurus.Error,
"error": taurus.Error,
"2": taurus.Warning,
"warning": taurus.Warning,
"3": taurus.Info,
"info": taurus.Info,
"4": taurus.Debug,
"debug": taurus.Debug,
"5": taurus.Trace,
"trace": taurus.Trace,
}
log_output_level = log_level_map[log_output_level]
root.handlers[0].setLevel(log_output_level)
if not options.without_log_file:
log_file_level = options.log_file_level
log_file_level = log_level_map[log_file_level]
# Create a file handler
if options.log_file_name is None:
_, ds_name = os.path.split(args[0])
ds_name, _ = os.path.splitext(ds_name)
ds_instance = args[-1].lower()
import getpass
try:
# include the user name to avoid permission errors
tangodir = 'tango-%s' % getpass.getuser()
except:
tangodir = 'tango' % getpass.getuser()
path = os.path.join(os.sep, "tmp", tangodir, ds_name, ds_instance)
log_file_name = os.path.join(path, 'log.txt')
else:
log_file_name = options.log_file_name
path = os.path.dirname(log_file_name)
# because some versions of python have a bug in logging.shutdown (this
# function is not protected against deleted handlers) we store the
# handlers we create to make sure a strong reference exists when the
# logging.shutdown is called
taurus._handlers = handlers = []
try:
if not os.path.exists(path):
os.makedirs(path, 0777)
from sardana import sardanacustomsettings
maxBytes = getattr(sardanacustomsettings, 'LOG_FILES_SIZE', 1E7)
backupCount = getattr(sardanacustomsettings, 'LOG_BCK_COUNT', 5)
fmt = Logger.getLogFormat()
f_h = logging.handlers.RotatingFileHandler(log_file_name,
maxBytes=maxBytes,
backupCount=backupCount)
f_h.setFormatter(fmt)
f_h.setLevel(log_file_level)
root.addHandler(f_h)
handlers.append(f_h)
if start_time is not None:
taurus.info("Started at %s", start_time)
else:
taurus.info("Starting up...")
taurus.info("Log is being stored in %s", log_file_name)
except:
if start_time is not None:
taurus.info("Started at %s", start_time)
else:
taurus.info("Starting up...")
taurus.warning(
"'%s' could not be created. Logs will not be stored",
log_file_name)
taurus.debug("Error description", exc_info=1)
if log_messages is None:
log_messages = []
for log_message in log_messages:
taurus.info(*log_message)
taurus.debug("Start args=%s", args)
taurus.debug("Start tango args=%s", tango_args)
taurus.debug("Start options=%s", options)
taurus.debug("Using PyTango %s from %s", PyTango.Release.version,
PyTango.__path__[0])
taurus.debug("Using taurus %s from %s", taurus.Release.version,
taurus.__path__[0])
taurus.debug("Using sardana %s from %s", sardana.Release.version,
sardana.__path__[0])
def tearDownClass(cls):
"""Terminate the epics_test softIoc process"""
if cls._process:
cls._process.terminate()
else:
taurus.warning('Process not started, cannot terminate it.')
def prepare_logging(options, args, tango_args, start_time=None, log_messages=None):
taurus.setLogLevel(taurus.Debug)
root = Logger.getRootLog()
# output logger configuration
log_output_level = options.log_level
log_level_map = { "0" : taurus.Critical, "critical" : taurus.Critical,
"1" : taurus.Error, "error" : taurus.Error,
"2" : taurus.Warning, "warning" : taurus.Warning,
"3" : taurus.Info, "info" : taurus.Info,
"4" : taurus.Debug, "debug" : taurus.Debug,
"5" : taurus.Trace, "trace" : taurus.Trace,
}
log_output_level = log_level_map[log_output_level]
root.handlers[0].setLevel(log_output_level)
if not options.without_log_file:
log_file_level = options.log_file_level
log_file_level = log_level_map[log_file_level]
# Create a file handler
if options.log_file_name is None:
_, ds_name = os.path.split(args[0])
ds_name, _ = os.path.splitext(ds_name)
ds_instance = args[-1].lower()
import getpass
try:
tangodir = 'tango-%s' % getpass.getuser() #include the user name to avoid permission errors
except:
tangodir = 'tango' % getpass.getuser()
path = os.path.join(os.sep, "tmp", tangodir, ds_name, ds_instance)
log_file_name = os.path.join(path, 'log.txt')
else:
log_file_name = options.log_file_name
path = os.path.dirname(log_file_name)
# because some versions of python have a bug in logging.shutdown (this
# function is not protected against deleted handlers) we store the
# handlers we create to make sure a strong reference exists when the
# logging.shutdown is called
taurus._handlers = handlers = []
try:
if not os.path.exists(path):
os.makedirs(path, 0777)
from sardana import sardanacustomsettings
maxBytes = getattr(sardanacustomsettings, 'LOG_FILES_SIZE', 1E7)
backupCount = getattr(sardanacustomsettings, 'LOG_BCK_COUNT', 5)
fmt = Logger.getLogFormat()
f_h = logging.handlers.RotatingFileHandler(log_file_name,
maxBytes=maxBytes,
backupCount=backupCount)
f_h.setFormatter(fmt)
f_h.setLevel(log_file_level)
root.addHandler(f_h)
handlers.append(f_h)
if start_time is not None:
taurus.info("Started at %s", start_time)
else:
taurus.info("Starting up...")
taurus.info("Log is being stored in %s", log_file_name)
except:
if start_time is not None:
taurus.info("Started at %s", start_time)
else:
taurus.info("Starting up...")
taurus.warning("'%s' could not be created. Logs will not be stored",
log_file_name)
taurus.debug("Error description", exc_info=1)
if log_messages is None:
log_messages = []
for log_message in log_messages:
taurus.info(*log_message)
taurus.debug("Start args=%s", args)
taurus.debug("Start tango args=%s", tango_args)
taurus.debug("Start options=%s", options)
taurus.debug("Using PyTango %s from %s", PyTango.Release.version, PyTango.__path__[0])
taurus.debug("Using taurus %s from %s", taurus.Release.version, taurus.__path__[0])
taurus.debug("Using sardana %s from %s", sardana.Release.version, sardana.__path__[0])
def set_properties_on_curves(properties, curves, plotItem=None, y2Axis=None):
"""
Sets properties provided in the `properties` dict to curves provided in
the `curves` dict. The association of a given curve with a property is
done by matching the keys in the respective dictionaries.
If both `plotItem` and `y2Axis` are passed, the curve will be moved to the
ViewBox defined in the .y2 property
:param properties: dict whose values are :class:`CurveAppearanceProperties`
instances and whose keys arbitrarily identify a
given curve
:param curves: dict whose values are :class:`PlotDataItem` instances
and whose keys match those of properties (if a key in
`curves` does not exist in `properties`, it will be ignored)
:param plotItem: The :class:`PlotItem` containing the dataItem.
:param y2Axis: The :class:`Y2ViewBox` instance
e skipp """
for key, dataItem in curves.items():
try:
prop = properties[key]
except KeyError:
warning("Cannot restore curve '%s' (no known properties)", key)
continue
sStyle = prop.sStyle
sSize = prop.sSize
sColor = prop.sColor
sFill = prop.sFill
lStyle = prop.lStyle
lWidth = prop.lWidth
lColor = prop.lColor
cFill = prop.cFill
stepMode = prop.stepMode
y2 = prop.y2
title = prop.title
dataItem.setPen(dict(style=lStyle, width=lWidth, color=lColor))
if cFill is not None:
dataItem.setFillLevel(cFill)
try:
cFillColor = Qt.QColor(lColor)
cFillColor.setAlphaF(0.5) # set to semitransparent
except Exception:
cFillColor = lColor
dataItem.setFillBrush(cFillColor)
else:
dataItem.setFillLevel(None)
dataItem.setSymbol(sStyle)
# dataItem.setSymbolPen(pyqtgraph.mkPen(color=sColor))
if sStyle is None or sSize < 0:
dataItem.setSymbolSize(0)
else:
dataItem.setSymbolSize(sSize)
if sFill:
dataItem.setSymbolBrush(pyqtgraph.mkColor(sColor))
else:
dataItem.setSymbolBrush(None)
dataItem.opts["stepMode"] = stepMode
dataItem.updateItems()
if title is not None:
# set the title of the curve
dataItem.setData(name=title)
# update the corresponding label in the legend
if plotItem is not None and plotItem.legend is not None:
if hasattr(plotItem.legend, "getLabel"):
plotItem.legend.getLabel(dataItem).setText(title)
else:
# workaround for pyqtgraph<=0.11 (getLabel not implemented)
for sample, label in plotItem.legend.items:
if sample.item == dataItem:
label.setText(title)
break
# act on the ViewBoxes only if plotItem and y2Axis are given
if plotItem and y2Axis:
set_y_axis_for_curve(y2, dataItem, plotItem, y2Axis)
def updateModels(self, xy_names):
"""
Update the current plot item list with the given configuration items
"""
mainViewBox = self.plot_item.getViewBox()
# Remove existing taurus curves from the plot (but keep the item object
# and a reference to their viewbox so that they can be readded
# later on if needed.
currentModelItems = OrderedDict()
_currentCurves = list(self.plot_item.listDataItems())
for curve in _currentCurves:
if isinstance(curve, self.itemClass):
xname, yname = curve.getFullModelNames()
viewbox = curve.getViewBox()
# store curve and current viewbox for later use
currentModelItems[(xname, yname)] = curve, viewbox
# remove the curve
self.plot_item.removeItem(curve)
# if viewbox is not mainViewBox: # TODO: do we need this?
# viewbox.removeItem(curve)
if self.legend is not None:
self.legend.removeItem(curve.name())
# Add only the curves defined in xy_names (reusing existing ones and
# creating those that did not exist) in the desired z-order
_already_added = []
for xy_name in xy_names:
# each member of xy_names can be yname or a (xname, yname) tuple
if isinstance(xy_name, string_types):
xname, yname = None, xy_name
else:
xname, yname = xy_name
# make sure that fullnames are used
try:
if xname is not None:
xmodel = taurus.Attribute(xname)
xname = xmodel.getFullName()
ymodel = taurus.Attribute(yname)
yname = ymodel.getFullName()
except Exception as e:
from taurus import warning
warning("Problem adding %r: %r", (xname, yname), e)
continue
# do not add it again if we already added it (avoid duplications)
if (xname, yname) in _already_added:
continue
_already_added.append((xname, yname))
# if the item already existed, re-use it
if (xname, yname) in currentModelItems:
item, viewbox = currentModelItems[(xname, yname)]
self.plot_item.addItem(item)
if viewbox is not mainViewBox:
# if the curve was originally associated to a viewbox
# other than the main one, we should move it there after
# re-adding it to the plot_item
mainViewBox.removeItem(item)
viewbox.addItem(item)
# if it is a new curve, create it and add it to the main plot_item
else:
item = self.itemClass(xModel=xname,
yModel=yname,
name=ymodel.getSimpleName())
if self._curveColors is not None:
item.setPen(self._curveColors.next().color())
self.plot_item.addItem(item)
def _onTriggered(self):
currentModelItems = {}
currentModelNames = []
taurusItems = []
for curve in self.plot_item.listDataItems():
if isinstance(curve, TaurusPlotDataItem):
xmodel, ymodel = curve.getFullModelNames()
currentModelNames.append((xmodel, ymodel))
currentModelItems[(xmodel, ymodel)] = curve, curve.getViewBox()
taurusItems.append(TaurusItemConf(YModel=ymodel, XModel=xmodel,
name=curve.name()))
conf, ok = TaurusItemConfDlg.showDlg(
parent=self.parent(), taurusItemConf=taurusItems)
# print conf, ok
if ok:
yModels = OrderedDict()
xModels = OrderedDict()
curve_name = OrderedDict()
for c in conf:
try:
# print c.yModel, type(c.yModel)
m = taurus.Attribute(c.yModel)
n = c.xModel
name = c.curveLabel
yModels[n, m.getFullName()] = m
xModels[n, m.getFullName()] = n
curve_name[n, m.getFullName()] = name
except Exception as e:
from taurus import warning
warning(e)
for k, v in currentModelItems.items():
curve, parent = v
self.plot_item.removeItem(curve)
parent.removeItem(curve)
if self.legend is not None:
self.legend.removeItem(curve.name())
for modelName, model in yModels.items():
# print modelName, model
if modelName in currentModelNames:
item, parent = currentModelItems[modelName]
X = xModels[modelName]
c_name = curve_name[modelName]
item.opts['name'] = c_name
item.setXModel(X)
self.plot_item.addItem(item)
# checks if the viewBox associated to
# TaurusPlotDataItem(curve), it is the main view or not.
# If is the same, we dont have to addItem again in the
# parent (viewBox). This avoid duplicate objects in the
# ViewBox.scene() contained in PlotItem.
if parent is not self.plot_item.getViewBox():
parent.addItem(item)
elif modelName not in currentModelNames:
x_model = xModels[modelName]
y_model = yModels[modelName]
c_name = curve_name[modelName]
item = TaurusPlotDataItem(
xModel=x_model, yModel=y_model, name=c_name)
if self._curveColors is not None:
item.setPen(self._curveColors.next().color())
self.plot_item.addItem(item)
def tearDownClass(cls):
"""Terminate the epics_test softIoc process"""
if cls._process:
cls._process.terminate()
else:
taurus.warning('Process not started, cannot terminate it.')
def __init__(self, *args, **kwargs):
msg = ('%s is deprecated. Use "Authority" instead of "Database"' %
self.__class__.__name__)
from taurus import warning
warning(msg)
return TaurusAuthorityNameValidator.__init__(self, *args, **kwargs)
def fillWithChildren(self):
frame = TaurusWidget()
frame.setLayout(Qt.QGridLayout())
frame.layout().addItem(
Qt.QSpacerItem(0, 0, Qt.QSizePolicy.Minimum,
Qt.QSizePolicy.MinimumExpanding))
parent_name = None
if self.getUseParentModel():
parent_model = self.getParentModelObj()
if parent_model:
parent_name = parent_model.getFullName()
for i, model in enumerate(self.getModel()):
if not model:
continue
try:
model_obj = taurus.Object(model)
except:
self.warning('problem adding item "%s"', model)
self.traceback(level=taurus.Debug)
continue
if parent_name:
# @todo: Change this (it assumes tango model naming!)
model = "%s/%s" % (parent_name, model)
widget = None
# check if some item factory handles this model
for ep in self._itemFactories:
try:
# load the plugin
f = ep.load()
except:
warning('cannot load item factory "%s"', ep.name)
continue
try:
widget = f(model_obj)
except Exception as e:
warning(
'factory "%s" raised "%r" for "%s". ' +
'Tip: consider disabling it', ep.name, e, model)
if widget is not None:
self.debug("widget for '%s' provided by '%s'", model,
ep.name)
break
# backwards-compat with deprecated custom widget map API
if widget is None and self._customWidgetMap:
widget = self._customWidgetFactory(model_obj)
# no factory handles the model and no custom widgets. Use default
if widget is None:
widget = self._defaultFormWidget()
# @todo UGLY... See if this can be done in other ways... (this causes trouble with widget that need more vertical space , like PoolMotorTV)
widget.setMinimumHeight(20)
try:
widget.setCompact(self.isCompact())
widget.setModel(model)
widget.setParent(frame)
except:
# raise
self.warning('problem adding item "%s"', model)
self.traceback(level=taurus.Debug)
try:
widget.setModifiableByUser(self.isModifiableByUser())
except:
pass
try:
widget.setFormat(self.getFormat())
except Exception:
self.debug('Cannot set format %s to child %s',
self.getFormat(), model)
widget.setObjectName("__item%i" % i)
self.registerConfigDelegate(widget)
self._children.append(widget)
frame.layout().addItem(
Qt.QSpacerItem(0, 0, Qt.QSizePolicy.Minimum,
Qt.QSizePolicy.MinimumExpanding))
self.scrollArea.setWidget(frame)
# self.scrollArea.setWidgetResizable(True)
self.scrollArea.setMinimumWidth(frame.layout().sizeHint().width() + 20)
def __init__(self, *args, **kwargs):
msg = ('%s is deprecated. Use "Authority" instead of "Database"' %
self.__class__.__name__)
from taurus import warning
warning(msg)
return TaurusAuthorityNameValidator.__init__(self, *args, **kwargs)
