def init(self, *args, **kwargs):
"""Singleton instance initialization."""
if PyTangoArchiving is None:
raise TaurusException('PyTangoArchiving is not available')
name = self.__class__.__name__
Logger.__init__(self, name)
TaurusFactory.__init__(self)
def __init__(self, parent=None, data=None):
Qt.QAbstractItemModel.__init__(self, parent)
Logger.__init__(self)
self._data_src = None
self._rootItem = None
self._filters = []
self._selectables = [self.ColumnRoles[0][-1]]
self.setDataSource(data)
def __init__(self, **kwargs):
EventGenerator.__init__(self)
EventReceiver.__init__(self)
self._type = kwargs.pop('elem_type')
self._name = intern(kwargs.pop('name'))
self._full_name = intern(kwargs.pop('full_name'))
self._frontend = None
Logger.__init__(self, self._name)
self._manager = weakref.ref(kwargs.pop('manager'))
self._parent = weakref.ref(kwargs.pop('parent', self.manager))
def __init__(self, job, callback, th_id, stack, *args, **kwargs):
name = self.__class__.__name__
threading.Thread.__init__(self, name=name)
Logger.__init__(self, name)
self.job = job
self.callback = callback
self.th_id = th_id
self.stack = stack
self.args = args
self.kwargs = kwargs
def __init__(self, **kwargs):
EventGenerator.__init__(self)
EventReceiver.__init__(self)
self._type = kwargs.pop('elem_type')
self._name = intern(kwargs.pop('name'))
self._full_name = intern(kwargs.pop('full_name'))
self._frontend = None
Logger.__init__(self, self._name)
self._manager = weakref.ref(kwargs.pop('manager'))
self._parent = weakref.ref(kwargs.pop('parent', self.manager))
def __init__(self, main_element, name="GlobalAction"):
Logger.__init__(self, name)
self._action_run_lock = threading.Lock()
self._main_element = weakref.ref(main_element)
self._aborted = False
self._stopped = False
self._elements = []
self._pool_ctrl_dict = {}
self._pool_ctrl_list = []
self._finish_hook = None
self._running = False
self._state_info = OperationInfo()
self._value_info = OperationInfo()
def __init__(self, parent=None, data=None):
Qt.QAbstractItemModel.__init__(self, parent)
Logger.__init__(self)
# if qt < 4.6, beginResetModel and endResetModel don't exist. In this
# case we set beginResetModel to be an empty function and endResetModel
# to be reset.
if not hasattr(Qt.QAbstractItemModel, "beginResetModel"):
self.beginResetModel = lambda: None
self.endResetModel = self.reset
self._data_src = None
self._rootItem = None
self._filters = []
self._selectables = [self.ColumnRoles[0][-1]]
self.setDataSource(data)
def __init__(self, pool, name='PoolMonitor', period=5.0, min_sleep=1.0,
auto_start=True):
Logger.__init__(self, name)
threading.Thread.__init__(self, name=name)
self.daemon = True
self._period = period
self._min_sleep = min_sleep
self._pool = pool
self._stop = False
self._pause = threading.Event()
self._thread_pool = None
self._ctrl_ids = []
self._elem_ids = []
pool.add_listener(self.on_pool_changed)
if not auto_start:
self.pause()
self.start()
def __init__(self, name="FunctionGenerator"):
EventGenerator.__init__(self)
Logger.__init__(self, name)
self._name = name
self._initial_domain = None
self._active_domain = None
self._position_event = threading.Event()
self._initial_domain_in_use = None
self._active_domain_in_use = None
self._active_events = list()
self._passive_events = list()
self._started = False
self._stopped = False
self._running = False
self._start_time = None
self._direction = None
self._condition = None
self._id = None
def __init__(self, name='', parent=None, format=None, std=None,
pure_text=True):
"""The STD Logger constructor
:param name: (str) the logger name (default is empty string)
:param parent: (Logger) the parent logger or None if no parent exists
(default is None)
:param format: (str) the log message format or None to use the default
log format (default is None)
:param std: std to forward write
:param pure_text: if True, writes the 'message' parameter of the log
message in a separate line preserving the
indentation
"""
Logger.__init__(self, name=name, parent=parent, format=format)
self.buffer = ''
self.log_obj.propagate = False
self.std = std
def __init__(self, name='', parent=None, format=None, std=None,
pure_text=True):
"""The STD Logger constructor
:param name: (str) the logger name (default is empty string)
:param parent: (Logger) the parent logger or None if no parent exists
(default is None)
:param format: (str) the log message format or None to use the default
log format (default is None)
:param std: std to forward write
:param pure_text: if True, writes the 'message' parameter of the log
message in a separate line preserving the
indentation
"""
Logger.__init__(self, name=name, parent=parent, format=format)
self.buffer = ''
self.log_obj.propagate = False
self.std = std
def __init__(self, name="FunctionGenerator"):
EventGenerator.__init__(self)
Logger.__init__(self, name)
self._name = name
self._initial_domain = None
self._active_domain = None
self._position_event = threading.Event()
self._position = None
self._initial_domain_in_use = None
self._active_domain_in_use = None
self._active_events = list()
self._passive_events = list()
self._started = False
self._stopped = False
self._running = False
self._start_time = None
self._direction = None
self._condition = None
self._id = None
self._start_fired = False
def __init__(self, dclass, name):
"""Constructor"""
self.in_constructor = True
try:
Device_4Impl.__init__(self, dclass, name)
self.init(name)
Logger.__init__(self, name)
self._state = DevState.INIT
self._status = 'Waiting to be initialized...'
# access to some tango API (like MultiAttribute and Attribute) is
# still not thread safe so we have this lock to protect
# Wa can't always use methods which use internally the
# C++ AutoTangoMonitor because it blocks the entire tango device.
self.tango_lock = threading.RLock()
self._event_thread_pool = get_thread_pool()
self.init_device()
finally:
self.in_constructor = False
def __init__(self, dclass, name):
"""Constructor"""
self.in_constructor = True
try:
Device_4Impl.__init__(self, dclass, name)
self.init(name)
Logger.__init__(self, name)
self._state = DevState.INIT
self._status = 'Waiting to be initialized...'
# access to some tango API (like MultiAttribute and Attribute) is
# still not thread safe so we have this lock to protect
# Wa can't always use methods which use internally the
# C++ AutoTangoMonitor because it blocks the entire tango device.
self.tango_lock = threading.RLock()
self._event_thread_pool = get_thread_pool()
self.init_device()
finally:
self.in_constructor = False
def __init__(self,
pool,
name='PoolMonitor',
period=5.0,
min_sleep=1.0,
auto_start=True):
Logger.__init__(self, name)
threading.Thread.__init__(self, name=name)
self.daemon = True
self._period = period
self._min_sleep = min_sleep
self._pool = pool
self._stop = False
self._pause = threading.Event()
self._thread_pool = None
self._ctrl_ids = []
self._elem_ids = []
pool.add_listener(self.on_pool_changed)
if not auto_start:
self.pause()
self.start()
def __init__(self, widget, fileName):
Qt.QObject.__init__(self)
Logger.__init__(self)
self._widget = widget
self._fileName = fileName
self.grab.connect(self.onGrab)
def __init__(self, *args, **kwargs):
"""The constructor. Parameters are the same as QApplication plus a
keyword parameter: 'cmd_line_parser' which should be an instance of
:class:`optparse.OptionParser`"""
# lock to safely get singleton elements (like IPython taurus
# console app)
self._lock = threading.Lock()
if len(args) == 0:
args = getattr(sys, 'argv', []),
parser = None
app_name, app_version, org_name, org_domain = None, None, None, None
if 'app_name' in kwargs:
app_name = kwargs.pop('app_name')
if 'app_version' in kwargs:
app_version = kwargs.pop('app_version')
if 'org_name' in kwargs:
org_name = kwargs.pop('org_name')
if 'org_domain' in kwargs:
org_domain = kwargs.pop('org_domain')
if 'cmd_line_parser' in kwargs:
parser = kwargs.pop('cmd_line_parser')
try:
Qt.QApplication.__init__(self, *args, **kwargs)
except TypeError:
Qt.QApplication.__init__(self, *args)
Logger.__init__(self)
self._out = None
self._err = None
if app_name is not None:
self.setApplicationName(app_name)
if app_version is not None:
self.setApplicationVersion(app_version)
if org_name is not None:
self.setOrganizationName(org_name)
if org_domain is not None:
self.setOrganizationDomain(org_domain)
# if the constructor was called without a parser or with a parser that
# doesn't contain version information and with an application
# name and/or version, then add the --version capability
if (parser is None or parser.version is None) and app_version:
v = app_version
if app_name:
v = app_name + " " + app_version
if parser is None:
parser = optparse.OptionParser(version=v)
elif parser.version is None:
parser.version = v
parser._add_version_option()
p, opt, args = \
taurus.core.util.argparse.init_taurus_args(
parser=parser, args=args[0][1:])
self._cmd_line_parser = p
self._cmd_line_options = opt
self._cmd_line_args = args
self.__registerQtLogger()
self.__registerExtensions()
self.__redirect_std()
def __init__(self, widget, fileName):
Qt.QObject.__init__(self)
Logger.__init__(self)
self._widget = widget
self._fileName = fileName
self.connect(self, Qt.SIGNAL("grab"), self.onGrab)
def __init__(self, *args, **kwargs):
"""The constructor. Parameters are the same as QApplication plus a
keyword parameter: 'cmd_line_parser' which should be None or an
instance of :class:`optparse.OptionParser`. If cmd_line_parser is None
no command line parsing will be done ()
"""
# lock to safely get singleton elements (like IPython taurus
# console app)
self._lock = threading.Lock()
if len(args) == 0:
args = getattr(sys, 'argv', []),
app_name = kwargs.pop('app_name', None)
app_version = kwargs.pop('app_version', None)
org_name = kwargs.pop('org_name', None)
org_domain = kwargs.pop('org_domain', None)
if getattr(tauruscustomsettings, 'IMPLICIT_OPTPARSE', True):
import optparse
default_parser = optparse.OptionParser()
else:
default_parser = None
parser = kwargs.pop('cmd_line_parser', default_parser)
#######################################################################
# Workaround for XInitThreads-related crash.
# Sometimes (e.g. running `taurusgui example01`) one gets the following:
# [xcb] Unknown request in queue while dequeuing
# [xcb] Most likely this is a multi-threaded client and XInitThreads has not been called
# [xcb] Aborting, sorry about that.
#
# According to http://stackoverflow.com/a/31967769 , it is fixed by:
try:
Qt.QCoreApplication.setAttribute(Qt.Qt.AA_X11InitThreads)
except AttributeError:
pass # Qt < 4.8 does not define AA_X11InitThreads
######################################################################
try:
Qt.QApplication.__init__(self, *args, **kwargs)
except TypeError:
Qt.QApplication.__init__(self, *args)
Logger.__init__(self)
self._out = None
self._err = None
if app_name is not None:
self.setApplicationName(app_name)
if app_version is not None:
self.setApplicationVersion(app_version)
if org_name is not None:
self.setOrganizationName(org_name)
if org_domain is not None:
self.setOrganizationDomain(org_domain)
if parser is None:
p, opt, args = None, None, None
else:
try:
if parser.version is None and app_version:
# if the parser does not contain version information
# but we have an application version, add the
# --version capability
v = app_version
if app_name:
v = app_name + " " + app_version
parser.version = v
parser._add_version_option()
import taurus.core.util.argparse
p, opt, args = taurus.core.util.argparse.init_taurus_args(
parser=parser, args=args[0][1:])
except Exception:
self.error("Error while using the given cmd_line_parser. \n"
+ "hint: it must be either None or an "
+ "optparse.OptionParser instance")
raise
self._cmd_line_parser = p
self._cmd_line_options = opt
self._cmd_line_args = args
self.__registerQtLogger()
self.__registerExtensions()
self.__redirect_std()
def init(self, *args, **kwargs):
"""Singleton instance initialization."""
name = self.__class__.__name__
Logger.__init__(self, name)
TaurusFactory.__init__(self)
self.scheme = "h5file"
def __init__(self, widget, fileName):
Qt.QObject.__init__(self)
Logger.__init__(self)
self._widget = widget
self._fileName = fileName
self.grab.connect(self.onGrab)
def __init__(self, *args, **kwargs):
"""The constructor. Parameters are the same as QApplication plus a
keyword parameter: 'cmd_line_parser' which should be an instance of
:class:`optparse.OptionParser`"""
# lock to safely get singleton elements (like IPython taurus
# console app)
self._lock = threading.Lock()
if len(args) == 0:
args = getattr(sys, 'argv', []),
parser = None
app_name, app_version, org_name, org_domain = None, None, None, None
if 'app_name' in kwargs:
app_name = kwargs.pop('app_name')
if 'app_version' in kwargs:
app_version = kwargs.pop('app_version')
if 'org_name' in kwargs:
org_name = kwargs.pop('org_name')
if 'org_domain' in kwargs:
org_domain = kwargs.pop('org_domain')
if 'cmd_line_parser' in kwargs:
parser = kwargs.pop('cmd_line_parser')
try:
Qt.QApplication.__init__(self, *args, **kwargs)
except TypeError:
Qt.QApplication.__init__(self, *args)
Logger.__init__(self)
self._out = None
self._err = None
if app_name is not None:
self.setApplicationName(app_name)
if app_version is not None:
self.setApplicationVersion(app_version)
if org_name is not None:
self.setOrganizationName(org_name)
if org_domain is not None:
self.setOrganizationDomain(org_domain)
# if the constructor was called without a parser or with a parser that
# doesn't contain version information and with an application
# name and/or version, then add the --version capability
if (parser is None or parser.version is None) and app_version:
v = app_version
if app_name:
v = app_name + " " + app_version
if parser is None:
parser = optparse.OptionParser(version=v)
elif parser.version is None:
parser.version = v
parser._add_version_option()
p, opt, args = \
taurus.core.util.argparse.init_taurus_args(
parser=parser, args=args[0][1:])
self._cmd_line_parser = p
self._cmd_line_options = opt
self._cmd_line_args = args
self.__registerQtLogger()
self.__registerExtensions()
self.__redirect_std()
def __init__(self, *args, **kwargs):
"""The constructor. Parameters are the same as QApplication plus a
keyword parameter: 'cmd_line_parser' which should be an instance of
:class:`optparse.OptionParser`"""
# lock to safely get singleton elements (like IPython taurus
# console app)
self._lock = threading.Lock()
if len(args) == 0:
args = getattr(sys, 'argv', []),
parser = None
app_name, app_version, org_name, org_domain = None, None, None, None
if 'app_name' in kwargs:
app_name = kwargs.pop('app_name')
if 'app_version' in kwargs:
app_version = kwargs.pop('app_version')
if 'org_name' in kwargs:
org_name = kwargs.pop('org_name')
if 'org_domain' in kwargs:
org_domain = kwargs.pop('org_domain')
if 'cmd_line_parser' in kwargs:
parser = kwargs.pop('cmd_line_parser')
#######################################################################
# Workaround for XInitThreads-related crash.
# Sometimes (e.g. running `taurusgui example01`) one gets the following:
# [xcb] Unknown request in queue while dequeuing
# [xcb] Most likely this is a multi-threaded client and XInitThreads has not been called
# [xcb] Aborting, sorry about that.
#
# According to http://stackoverflow.com/a/31967769 , it is fixed by:
try:
Qt.QCoreApplication.setAttribute(Qt.Qt.AA_X11InitThreads)
except AttributeError:
pass # Qt < 4.8 does not define AA_X11InitThreads
######################################################################
try:
Qt.QApplication.__init__(self, *args, **kwargs)
except TypeError:
Qt.QApplication.__init__(self, *args)
Logger.__init__(self)
self._out = None
self._err = None
if app_name is not None:
self.setApplicationName(app_name)
if app_version is not None:
self.setApplicationVersion(app_version)
if org_name is not None:
self.setOrganizationName(org_name)
if org_domain is not None:
self.setOrganizationDomain(org_domain)
# if the constructor was called without a parser or with a parser that
# doesn't contain version information and with an application
# name and/or version, then add the --version capability
if (parser is None or parser.version is None) and app_version:
v = app_version
if app_name:
v = app_name + " " + app_version
if parser is None:
parser = optparse.OptionParser(version=v)
elif parser.version is None:
parser.version = v
parser._add_version_option()
p, opt, args = \
taurus.core.util.argparse.init_taurus_args(
parser=parser, args=args[0][1:])
self._cmd_line_parser = p
self._cmd_line_options = opt
self._cmd_line_args = args
self.__registerQtLogger()
self.__registerExtensions()
self.__redirect_std()
