fandango.callbacks module

Contents

• fandango.callbacks module
  • Description
  • Classes
    • TAttr
    • EventStruct
    • EventListener
    • CachedAttributeProxy
    • TangoListener
    • EventCallback
    • EventSource
    • AttrCallback
    • TangoAttribute
    • EventThread
  • Functions
    • getEventFor
    • getSubscribedItems
    • setAttributeValue
    • inStatesList
    • getStateFor
    • setStateFor
    • inAttributesList
    • get_test_objects
    • subscribeDeviceAttributes
    • __test__
    • addTAttr
    • getEventItems
    • inEventsList
    • getAttrValueFor
    • addReceiver
  • raw autodoc

Description

## file : callbacks..py ## ## description : This class manages a list of attributes subscribed to events that could have multiple receivers each one. ## It supplies the ATK AttributeList behaviour. ## device.DevChild and those inherited classes depends on that. ## Global objects are: ## _EventsList, _EventReceivers, _StatesList, _AttributesList, GlobalCallback ## ... _EventReceivers must be substituted by DevicesList ## ## project : Tango Control System ## ## $Author: Sergi Rubio Manrique, srubio@cells.es $ ## ## $Revision: 2008 $ ## ## copyleft : ALBA Synchrotron Controls Section, CELLS ## Bellaterra ## Spain ## ############################################################################# ## ## This file is part of Tango Control System ## ## Tango Control System is free software; you can redistribute it and/or ## modify it under the terms of the GNU General Public License as published ## by the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## Tango Control System is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see <http://www.gnu.org/licenses/>. ###########################################################################

Classes

TAttr

class fandango.callbacks.TAttr(name, dev_name='', proxy=None, event_id=None)

This class is used to keep information about events received, example of usage inside device.DevChild

EventStruct

class fandango.callbacks.EventStruct

EventListener

class fandango.callbacks.EventListener(name, parent=None, source=False)

The EventListener class accepts 3 event hooks:

self.set_event_hook() self.set_error_hook() self.set_value_hook()

All of them need a callable accepting three arguments: src,type,value

In the case of value_hook it will not pass the event object but event.value/rvalue

eventReceived(src, type_, value)

Method to implement the event notification Source will be an object, type a PyTango EventType, evt_value an AttrValue

CachedAttributeProxy

class fandango.callbacks.CachedAttributeProxy(name, keeptime=1000.0, fake=False, parent=None, **kw)

TangoListener

class fandango.callbacks.TangoListener(name, parent=None, source=False)

The EventListener class accepts 3 event hooks:

self.set_event_hook() self.set_error_hook() self.set_value_hook()

All of them need a callable accepting three arguments: src,type,value

In the case of value_hook it will not pass the event object but event.value/rvalue

EventCallback

class fandango.callbacks.EventCallback

It provides persistent storage. lock.acquire and lock.release should be used to prevent threading problems!, Use of the lists inside push_event is safe

EventSource

class fandango.callbacks.EventSource(name, keeptime=1000.0, fake=False, parent=None, **kw)

Simplified implementation of Taurus Attribute/Model and fandango.CachedAttributeProxy classes

It implements CachedAttributeProxy methods but doesnt inherit from it; this regression is due to the lack of reliability of AttributeProxy in PyTango 9.

Documentation at doc/recipes/EventsAndCallbacks.rst

Slow Polling will be always enabled, as a KeepAlive is always kept reading the attribute values at an slow rate.

Well, will be always enabled as long there are Listeners or Forced is True. If not polling will not be activated and it will be simply a CachedAttributeProxy.

In this implementation, just a faster polling will be enabled if the attribute provides no events. But the slow polling will never be fully disabled.

If no events are received after EVENT_TIMEOUT, polling wil be also enabled.

It will also subscribe to all attribute events, not only CHANGE and CONFIG

All types are: ‘CHANGE_EVENT,PERIODIC_EVENT,QUALITY_EVENT,ARCHIVE_EVENT,ATTR_CONF_EVENT,DATA_READY_EVENT,USER_EVENT’

Arguments to EventSource(...) are:

• name : attribute name (simple or full)
• parent : device name or proxy
• enablePolling (force polling by default)
• pollingPeriod (3000)
• keeptime (500 ms) min. time (in ms!) between HW reads
• tango_asynch = True/False ; to use asynchronous Tango reading
• listeners = a list of listeners to be added at startup
• persistent = if True, a dummy listener is added to enforce subscription

Arguments are supported in CamelCase and lowercase to keep compatibility with previous apis (CachedProxy and TaurusAttribute).

Keep in mind that if tango_asynch=True; you will not get the latest value when doing read(cache=False). You must use read(cache=False,asynch=False) instead.

@TODO: Listeners should be assignable to only one type of eventl. @TODO: read(cache=False) should trigger fireEvent if not called from poll()

addListener(listener, use_events=True, use_polling=False)

Adds a Listener to this EventSource object. use_events can be a boolean or a list of event types (change,attr_conf,periodic,archive)

changePollingPeriod(period)

change polling period to period miliseconds

checkEvents(tdiff=None, vdiff=None)

tdiff: max time difference allowed between last_event_time and current time vdiff: difference between last event value and current hw value

fireEvent(event_type, event_value, listeners=None)

sends an event to all listeners or a specific one event type filtering is done here poll() events will be allowed to pass through

getMode()

SYNCHRONOUS = 0 EVENTS = 1 POLLED = 2

getPollingPeriod()

returns the polling period

hasListeners()

returns True if anybody is listening to events from this attribute

isPollingEnabled()

It should be called isPollingAllowed instead

isUsingEvents()

This method doesnt tell if it wants to use_events but if it is actually receiving them

read(cache=None, asynch=None, _raise=True)

Read last value acquired, if cache = False or not polled it will trigger a proxy.read_attribute() call.

If asynch=True/False, self.tango_asynch will be overriden for this call.

removeListener(listener, exclude='dummy')

Remove a listener object or callback. :listener: can be object, weakref, sequence or ‘*’

set_cache(value, t=None)

set_cache and fake are used by PyAlarm.update_locals It’s used to emulate alarm state reading from other devices

static thread()

It returns the current EventThread INSTANCE Use EventSource.thread().setup(...) to configure it

write(value, with_read=None)

The with_read argument will trigger a read() call and an update in all listeners

AttrCallback

class fandango.callbacks.AttrCallback(name='fandango.Logger', parent=None, format='%(levelname)-8s %(asctime)s %(name)s: %(message)s', use_tango=True, use_print=True, level='INFO', max_len=0)

TangoAttribute

class fandango.callbacks.TangoAttribute(name, keeptime=1000.0, fake=False, parent=None, **kw)

Simplified implementation of Taurus Attribute/Model and fandango.CachedAttributeProxy classes

It implements CachedAttributeProxy methods but doesnt inherit from it; this regression is due to the lack of reliability of AttributeProxy in PyTango 9.

Documentation at doc/recipes/EventsAndCallbacks.rst

Slow Polling will be always enabled, as a KeepAlive is always kept reading the attribute values at an slow rate.

Well, will be always enabled as long there are Listeners or Forced is True. If not polling will not be activated and it will be simply a CachedAttributeProxy.

In this implementation, just a faster polling will be enabled if the attribute provides no events. But the slow polling will never be fully disabled.

If no events are received after EVENT_TIMEOUT, polling wil be also enabled.

It will also subscribe to all attribute events, not only CHANGE and CONFIG

All types are: ‘CHANGE_EVENT,PERIODIC_EVENT,QUALITY_EVENT,ARCHIVE_EVENT,ATTR_CONF_EVENT,DATA_READY_EVENT,USER_EVENT’

Arguments to EventSource(...) are:

• name : attribute name (simple or full)
• parent : device name or proxy
• enablePolling (force polling by default)
• pollingPeriod (3000)
• keeptime (500 ms) min. time (in ms!) between HW reads
• tango_asynch = True/False ; to use asynchronous Tango reading
• listeners = a list of listeners to be added at startup
• persistent = if True, a dummy listener is added to enforce subscription

Arguments are supported in CamelCase and lowercase to keep compatibility with previous apis (CachedProxy and TaurusAttribute).

Keep in mind that if tango_asynch=True; you will not get the latest value when doing read(cache=False). You must use read(cache=False,asynch=False) instead.

@TODO: Listeners should be assignable to only one type of eventl. @TODO: read(cache=False) should trigger fireEvent if not called from poll()

EventThread

class fandango.callbacks.EventThread(period_ms=None, filtered=False, latency=10.0, loglevel='WARNING')

This class processes both Events and Polling. All listeners should implement eventReceived method All sources must have a listeners list On Current EventSource implementation this is a SINGLETONE!!!, its configuration will apply for the whole running process!

The filtered argument will just forward last event received on each loop iteration for each source. It can be set to False, True or a factor of latency.

The latency (ms) specifies a time condition to abort event checking and proceed to callback execution.

The real latency of the system is provided by inherited get_delay and get_avg_delay methods

fireEvent(source, *args)

It just retriggers every EventSource fireEvent method If there’s no method nor listeners, a callable is launched

process()

Currently, this implementation will process 100 events for each polling each time as max.

setup(period_ms=None, filtered=None, latency=None, loglevel=None)

This method allows to reconfigure an already running EventThread

Functions

getEventFor

fandango.callbacks.getEventFor(attname)

getSubscribedItems

fandango.callbacks.getSubscribedItems(receiver)

It returns a list with all devices managed by callbacks to which this receiver is effectively subscribed

setAttributeValue

fandango.callbacks.setAttributeValue(attr_name, attr_value)

inStatesList

fandango.callbacks.inStatesList(devname)

getStateFor

fandango.callbacks.getStateFor(devname)

setStateFor

fandango.callbacks.setStateFor(devname, state)

inAttributesList

fandango.callbacks.inAttributesList(attname)

get_test_objects

fandango.callbacks.get_test_objects(model='controls02:10000/test/sim/tonto/Pressure', period=1.0)

v,tl = fandango.callbacks.get_test_objects()

subscribeDeviceAttributes

fandango.callbacks.subscribeDeviceAttributes(self, dev_name, attrs)

This is how attributes were registered in the old PyStateComposer

__test__

fandango.callbacks.__test__(args)

addTAttr

fandango.callbacks.addTAttr(tattr)

getEventItems

fandango.callbacks.getEventItems()

inEventsList

fandango.callbacks.inEventsList(attname)

getAttrValueFor

fandango.callbacks.getAttrValueFor(attname)

addReceiver

fandango.callbacks.addReceiver(attribute, receiver)

---

raw autodoc

class fandango.callbacks.AttrCallback(name='fandango.Logger', parent=None, format='%(levelname)-8s %(asctime)s %(name)s: %(message)s', use_tango=True, use_print=True, level='INFO', max_len=0)

Bases: fandango.log.Logger, fandango.objects.Object

attr_read(*args, **kwargs)

class fandango.callbacks.CachedAttributeProxy(name, keeptime=1000.0, fake=False, parent=None, **kw)

Bases: fandango.callbacks.EventSource

class fandango.callbacks.EventCallback

It provides persistent storage. lock.acquire and lock.release should be used to prevent threading problems!, Use of the lists inside push_event is safe

push_event(event)

class fandango.callbacks.EventListener(name, parent=None, source=False)

Bases: fandango.log.Logger, fandango.objects.Object

The EventListener class accepts 3 event hooks:

self.set_event_hook() self.set_error_hook() self.set_value_hook()

All of them need a callable accepting three arguments: src,type,value

In the case of value_hook it will not pass the event object but event.value/rvalue

eventReceived(src, type_, value)

Method to implement the event notification Source will be an object, type a PyTango EventType, evt_value an AttrValue

set_error_hook(callable=None)

set_event_hook(callable=None)

set_value_hook(callable=None)

class fandango.callbacks.EventSource(name, keeptime=1000.0, fake=False, parent=None, **kw)

Bases: fandango.log.Logger, fandango.objects.SingletonMap

Simplified implementation of Taurus Attribute/Model and fandango.CachedAttributeProxy classes

It implements CachedAttributeProxy methods but doesnt inherit from it; this regression is due to the lack of reliability of AttributeProxy in PyTango 9.

Documentation at doc/recipes/EventsAndCallbacks.rst

Slow Polling will be always enabled, as a KeepAlive is always kept reading the attribute values at an slow rate.

Well, will be always enabled as long there are Listeners or Forced is True. If not polling will not be activated and it will be simply a CachedAttributeProxy.

In this implementation, just a faster polling will be enabled if the attribute provides no events. But the slow polling will never be fully disabled.

If no events are received after EVENT_TIMEOUT, polling wil be also enabled.

It will also subscribe to all attribute events, not only CHANGE and CONFIG

All types are: ‘CHANGE_EVENT,PERIODIC_EVENT,QUALITY_EVENT,ARCHIVE_EVENT,ATTR_CONF_EVENT,DATA_READY_EVENT,USER_EVENT’

Arguments to EventSource(...) are:

• name : attribute name (simple or full)
• parent : device name or proxy
• enablePolling (force polling by default)
• pollingPeriod (3000)
• keeptime (500 ms) min. time (in ms!) between HW reads
• tango_asynch = True/False ; to use asynchronous Tango reading
• listeners = a list of listeners to be added at startup
• persistent = if True, a dummy listener is added to enforce subscription

Arguments are supported in CamelCase and lowercase to keep compatibility with previous apis (CachedProxy and TaurusAttribute).

Keep in mind that if tango_asynch=True; you will not get the latest value when doing read(cache=False). You must use read(cache=False,asynch=False) instead.

@TODO: Listeners should be assignable to only one type of eventl. @TODO: read(cache=False) should trigger fireEvent if not called from poll()

DEFAULT_EVENTS = ['periodic', 'change', 'archive', 'quality']

DEFAULT_LOG = 'WARNING'

DUMMY = <fandango.callbacks.EventListener object at 0x7eff57513a50>

DefaultPolling = 3000.0

EVENT_TIMEOUT = 900

INSTANCES = []

KeepAlive = 15000.0

PROXIES = defaultdict(<bound method ProxiesDict.__default_factory__ of defaultdict(..., {})>, {})

QUEUE = None

STATES = fandango.Struct({ 'FORCED': 4, 'SUBSCRIBED': 3, 'FAILED': -1, 'UNSUBSCRIBED': 0, 'SUBSCRIBING': 2, 'PENDING': 1, })

TAURUS_EVENTS = ['change', 'attr_conf']

VALUE_EVENTS = ['periodic', 'change', 'archive', 'quality', 'user_event']

activatePolling(period=None, force=None)

addListener(listener, use_events=True, use_polling=False)

Adds a Listener to this EventSource object. use_events can be a boolean or a list of event types (change,attr_conf,periodic,archive)

asynch_hook()

changePollingPeriod(period)

change polling period to period miliseconds

checkEvents(tdiff=None, vdiff=None)

tdiff: max time difference allowed between last_event_time and current time vdiff: difference between last event value and current hw value

checkEventsReceived(types=None)

checkState(*states)

cleanUp()

deactivatePolling()

decodeAttrInfoEx(attr_conf)

disablePolling()

enablePolling(force=False)

fireEvent(event_type, event_value, listeners=None)

sends an event to all listeners or a specific one event type filtering is done here poll() events will be allowed to pass through

forcePolling(period=None)

getMode()

SYNCHRONOUS = 0 EVENTS = 1 POLLED = 2

getParent()

getParentObj()

getPollingPeriod()

returns the polling period

getValueObj()

hasListeners()

returns True if anybody is listening to events from this attribute

isPollingActive()

isPollingEnabled()

It should be called isPollingAllowed instead

isPollingForced()

isUsingEvents()

This method doesnt tell if it wants to use_events but if it is actually receiving them

poll()

push_event(event)

read(cache=None, asynch=None, _raise=True)

Read last value acquired, if cache = False or not polled it will trigger a proxy.read_attribute() call.

If asynch=True/False, self.tango_asynch will be overriden for this call.

removeListener(listener, exclude='dummy')

Remove a listener object or callback. :listener: can be object, weakref, sequence or ‘*’

resetStats()

setState(state)

set_cache(value, t=None)

set_cache and fake are used by PyAlarm.update_locals It’s used to emulate alarm state reading from other devices

static start_thread()

subscribeEvents(types=None, asynchronous=True)

static thread()

It returns the current EventThread INSTANCE Use EventSource.thread().setup(...) to configure it

unsubscribeEvents()

write(value, with_read=None)

The with_read argument will trigger a read() call and an update in all listeners

class fandango.callbacks.EventStruct

event = None

name = ''

receivers = []

class fandango.callbacks.EventThread(period_ms=None, filtered=False, latency=10.0, loglevel='WARNING')

Bases: fandango.log.Logger, fandango.threads.ThreadedObject

This class processes both Events and Polling. All listeners should implement eventReceived method All sources must have a listeners list On Current EventSource implementation this is a SINGLETONE!!!, its configuration will apply for the whole running process!

The filtered argument will just forward last event received on each loop iteration for each source. It can be set to False, True or a factor of latency.

The latency (ms) specifies a time condition to abort event checking and proceed to callback execution.

The real latency of the system is provided by inherited get_delay and get_avg_delay methods

EVENT_POLLING_RATIO = 1000

MinWait = 0.0001

fireEvent(source, *args)

It just retriggers every EventSource fireEvent method If there’s no method nor listeners, a callable is launched

get(*args, **kwargs)

get_pending()

get_source_name(source)

get_source_names(source='.*')

get_sources(source='.*')

has_source(source)

process()

Currently, this implementation will process 100 events for each polling each time as max.

put(*args)

register(source)

set_period_ms(period)

setup(period_ms=None, filtered=None, latency=None, loglevel=None)

This method allows to reconfigure an already running EventThread

wait(tout=None)

class fandango.callbacks.TAttr(name, dev_name='', proxy=None, event_id=None)

Bases: fandango.callbacks.EventStruct

This class is used to keep information about events received, example of usage inside device.DevChild

set(event)

class fandango.callbacks.TangoAttribute(name, keeptime=1000.0, fake=False, parent=None, **kw)

Bases: fandango.callbacks.EventSource

Simplified implementation of Taurus Attribute/Model and fandango.CachedAttributeProxy classes

It implements CachedAttributeProxy methods but doesnt inherit from it; this regression is due to the lack of reliability of AttributeProxy in PyTango 9.

Documentation at doc/recipes/EventsAndCallbacks.rst

Slow Polling will be always enabled, as a KeepAlive is always kept reading the attribute values at an slow rate.

Well, will be always enabled as long there are Listeners or Forced is True. If not polling will not be activated and it will be simply a CachedAttributeProxy.

In this implementation, just a faster polling will be enabled if the attribute provides no events. But the slow polling will never be fully disabled.

If no events are received after EVENT_TIMEOUT, polling wil be also enabled.

It will also subscribe to all attribute events, not only CHANGE and CONFIG

All types are: ‘CHANGE_EVENT,PERIODIC_EVENT,QUALITY_EVENT,ARCHIVE_EVENT,ATTR_CONF_EVENT,DATA_READY_EVENT,USER_EVENT’

Arguments to EventSource(...) are:

• name : attribute name (simple or full)
• parent : device name or proxy
• enablePolling (force polling by default)
• pollingPeriod (3000)
• keeptime (500 ms) min. time (in ms!) between HW reads
• tango_asynch = True/False ; to use asynchronous Tango reading
• listeners = a list of listeners to be added at startup
• persistent = if True, a dummy listener is added to enforce subscription

Arguments are supported in CamelCase and lowercase to keep compatibility with previous apis (CachedProxy and TaurusAttribute).

Keep in mind that if tango_asynch=True; you will not get the latest value when doing read(cache=False). You must use read(cache=False,asynch=False) instead.

@TODO: Listeners should be assignable to only one type of eventl. @TODO: read(cache=False) should trigger fireEvent if not called from poll()

class fandango.callbacks.TangoListener(name, parent=None, source=False)

Bases: fandango.callbacks.EventListener

The EventListener class accepts 3 event hooks:

self.set_event_hook() self.set_error_hook() self.set_value_hook()

All of them need a callable accepting three arguments: src,type,value

In the case of value_hook it will not pass the event object but event.value/rvalue

fandango.callbacks.addReceiver(attribute, receiver)

fandango.callbacks.addTAttr(tattr)

fandango.callbacks.getAttrValueFor(attname)

fandango.callbacks.getEventFor(attname)

fandango.callbacks.getEventItems()

fandango.callbacks.getStateFor(devname)

fandango.callbacks.getSubscribedItems(receiver)

It returns a list with all devices managed by callbacks to which this receiver is effectively subscribed

fandango.callbacks.get_test_objects(model='controls02:10000/test/sim/tonto/Pressure', period=1.0)

v,tl = fandango.callbacks.get_test_objects()

fandango.callbacks.inAttributesList(attname)

fandango.callbacks.inEventsList(attname)

fandango.callbacks.inStatesList(devname)

fandango.callbacks.setAttributeValue(attr_name, attr_value)

fandango.callbacks.setStateFor(devname, state)

fandango.callbacks.subscribeDeviceAttributes(self, dev_name, attrs)

This is how attributes were registered in the old PyStateComposer