AttributeProxy

class tango.AttributeProxy(*args, **kwds)

AttributeProxy is the high level Tango object which provides the client with an easy-to-use interface to TANGO attributes.

To create an AttributeProxy, a complete attribute name must be set in the object constructor.

Example:: att = AttributeProxy(“tango/tangotest/1/long_scalar”)

Note: PyTango implementation of AttributeProxy is in part a python reimplementation of the AttributeProxy found on the C++ API.

delete_property(self, value) → None

Delete a the given of properties for this attribute. This method accepts the following types as value parameter:

string [in] - single property to be deleted

tango.DbDatum [in] - single property data to be deleted

tango.DbData [in] - several property data to be deleted

sequence<string> [in]- several property data to be deleted

sequence<DbDatum> [in] - several property data to be deleted

dict<str, obj> [in] - keys are property names to be deleted (values are ignored)

dict<str, DbDatum> [in] - several DbDatum.name are property names to be deleted (keys are ignored)

Parameters:

value:

can be one of the following:

string [in] - single property data to be deleted
tango.DbDatum [in] - single property data to be deleted
tango.DbData [in] - several property data to be deleted
sequence<string> [in]- several property data to be deleted
sequence<DbDatum> [in] - several property data to be deleted
dict<str, obj> [in] - keys are property names to be deleted (values are ignored)
dict<str, DbDatum> [in] - several DbDatum.name are property names to be deleted (keys are ignored)

Return:

None

Throws:

ConnectionFailed, CommunicationFailed DevFailed from device (DB_SQLError), TypeError

event_queue_size(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().event_queue_size(…)

For convenience, here is the documentation of DeviceProxy.event_queue_size(…):

event_queue_size(self, event_id) -> int

Returns the number of stored events in the event reception buffer. After every call to DeviceProxy.get_events(), the event queue size is 0. During event subscription the client must have chosen the ‘pull model’ for this event. event_id is the event identifier returned by the DeviceProxy.subscribe_event() method.

Parameters:

event_id:

(int) event identifier

Return:

an integer with the queue size

Throws:

EventSystemFailed

New in PyTango 7.0.0

get_config(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().get_attribute_config(self.name(), …)

For convenience, here is the documentation of DeviceProxy.get_attribute_config(…):

get_attribute_config(self, name, green_mode=None, wait=True, timeout=None) -> AttributeInfoEx get_attribute_config(self, names, green_mode=None, wait=True, timeout=None) -> AttributeInfoList

Return the attribute configuration for a single or a list of attribute(s). To get all the attributes pass a sequence containing the constant tango.constants.AllAttr

Deprecated: use get_attribute_config_ex instead

param name:

Attribute name.

type name:

str

param names:

Attribute names.

type names:

sequence(str)

param green_mode:

Defaults to the current DeviceProxy GreenMode. See tango.DeviceProxy.get_green_mode and tango.DeviceProxy.set_green_mode for more details.

type green_mode:

GreenMode

param wait:

Specifies whether to wait for the result. If green_mode is Synchronous, this parameter is ignored as the operation always waits for the result. This parameter is also ignored when green_mode is Synchronous.

type wait:

bool

param timeout:

The number of seconds to wait for the result. If set to None, there is no limit on the wait time. This parameter is ignored when green_mode is Synchronous or when wait is False.

type timeout:

float, optional

returns:

An AttributeInfoEx or AttributeInfoList object containing the attribute(s) information.

rtype:

Union[AttributeInfoEx, AttributeInfoList]

raises ConnectionFailed:

Raised in case of a connection failure.

raises CommunicationFailed:

Raised in case of a communication failure.

raises DevFailed:

Raised in case of a device failure.

raises TypeError:

Raised in case of an incorrect type of input arguments.

get_device_proxy(self) → DeviceProxy

A method which returns the device associated to the attribute

Parameters:: None
Return:: (DeviceProxy)

get_events(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().get_events(…)

For convenience, here is the documentation of DeviceProxy.get_events(…):

get_events(self, event_id, callback=None, extract_as=Numpy) -> None

The method extracts all waiting events from the event reception buffer.

If callback is not None, it is executed for every event. During event subscription the client must have chosen the pull model for this event. The callback will receive a parameter of type EventData, AttrConfEventData or DataReadyEventData depending on the type of the event (event_type parameter of subscribe_event).

If callback is None, the method extracts all waiting events from the event reception buffer. The returned event_list is a vector of EventData, AttrConfEventData or DataReadyEventData pointers, just the same data the callback would have received.

param event_id:

The event identifier returned by the DeviceProxy.subscribe_event() method.

type event_id:

int

param callback:

Any callable object or any object with a “push_event” method.

type callback:

callable

param extract_as:

(Description Needed)

type extract_as:

ExtractAs

returns:

None

raises EventSystemFailed:

Raised in case of a failure in the event system.

raises TypeError:

Raised in case of an incorrect type of input arguments.

raises ValueError:

Raised in case of an invalid value.

see also:

subscribe_event()

get_last_event_date(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().get_last_event_date(…)

For convenience, here is the documentation of DeviceProxy.get_last_event_date(…):

get_last_event_date(self, event_id) -> TimeVal

Returns the arrival time of the last event stored in the event reception buffer. After every call to DeviceProxy:get_events(), the event reception buffer is empty. In this case an exception will be returned. During event subscription the client must have chosen the ‘pull model’ for this event. event_id is the event identifier returned by the DeviceProxy.subscribe_event() method.

Parameters:

event_id:

(int) event identifier

Return:

(tango.TimeVal) representing the arrival time

Throws:

EventSystemFailed

New in PyTango 7.0.0

get_poll_period(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().get_attribute_poll_period(self.name(), …)

For convenience, here is the documentation of DeviceProxy.get_attribute_poll_period(…):

get_attribute_poll_period(self, attr_name) -> int

Return the attribute polling period.

Parameters:

attr_name:

(str) attribute name

Return:

polling period in milliseconds

get_property(self, propname, value) → DbData

Get a (list) property(ies) for an attribute.

This method accepts the following types as propname parameter: 1. string [in] - single property data to be fetched 2. sequence<string> [in] - several property data to be fetched 3. tango.DbDatum [in] - single property data to be fetched 4. tango.DbData [in,out] - several property data to be fetched. 5. sequence<DbDatum> - several property data to be feteched

Note: for cases 3, 4 and 5 the ‘value’ parameter if given, is IGNORED.

If value is given it must be a tango.DbData that will be filled with the property values

Parameters:

propname:: (str) property(ies) name(s)
value:: (tango.DbData) (optional, default is None meaning that the method will create internally a tango.DbData and return it filled with the property values

Return:

(DbData) containing the property(ies) value(s). If a tango.DbData is given as parameter, it returns the same object otherwise a new tango.DbData is returned

Throws:

NonDbDevice, ConnectionFailed (with database), CommunicationFailed (with database), DevFailed from database device

get_transparency_reconnection(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().get_transparency_reconnection(…)

For convenience, here is the documentation of DeviceProxy.get_transparency_reconnection(…):

get_transparency_reconnection(self) -> bool

Returns the device transparency reconnection flag.

Parameters:

None

Return:

(bool) True if transparency reconnection is set or False otherwise

history(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().attribute_history(self.name(), …)

For convenience, here is the documentation of DeviceProxy.attribute_history(…):

attribute_history(self, attr_name, depth, extract_as=ExtractAs.Numpy) -> sequence<DeviceAttributeHistory>

Retrieve attribute history from the attribute polling buffer. See chapter on Advanced Feature for all details regarding polling

Parameters:

attr_name:

(str) Attribute name.

depth:

(int) The wanted history depth.

extract_as:

(ExtractAs)

Return:

This method returns a vector of DeviceAttributeHistory types.

Throws:

NonSupportedFeature, ConnectionFailed, CommunicationFailed, DevFailed from device

is_event_queue_empty(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().is_event_queue_empty(…)

For convenience, here is the documentation of DeviceProxy.is_event_queue_empty(…):

is_event_queue_empty(self, event_id) -> bool

Returns true when the event reception buffer is empty. During event subscription the client must have chosen the ‘pull model’ for this event. event_id is the event identifier returned by the DeviceProxy.subscribe_event() method.

Parameters:

event_id:

(int) event identifier

Return:

(bool) True if queue is empty or False otherwise

Throws:

EventSystemFailed

New in PyTango 7.0.0

is_polled(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().is_attribute_polled(self.name(), …)

For convenience, here is the documentation of DeviceProxy.is_attribute_polled(…):

is_attribute_polled(self, attr_name) -> bool

True if the attribute is polled.

param str attr_name:

attribute name

returns:

boolean value

rtype:

bool

name(self) → str

Returns the attribute name

Parameters:: None
Return:: (str) with the attribute name

ping(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().ping(…)

For convenience, here is the documentation of DeviceProxy.ping(…):

ping(self, green_mode=None, wait=True, timeout=True) -> int

A method which sends a ping to the device

Parameters:

green_mode:

(GreenMode) Defaults to the current DeviceProxy GreenMode. (see get_green_mode() and set_green_mode()).

wait:

(bool) whether or not to wait for result. If green_mode is Synchronous, this parameter is ignored as it always waits for the result. Ignored when green_mode is Synchronous (always waits).

timeout:

(float) The number of seconds to wait for the result. If None, then there is no limit on the wait time. Ignored when green_mode is Synchronous or wait is False.

Return:

(int) time elapsed in microseconds

Throws:

exception if device is not alive

poll(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().poll_attribute(self.name(), …)

For convenience, here is the documentation of DeviceProxy.poll_attribute(…):

poll_attribute(self, attr_name, period) -> None

Add an attribute to the list of polled attributes.

Parameters:

attr_name:

(str) attribute name

period:

(int) polling period in milliseconds

Return:

None

put_property(self, value) → None

Insert or update a list of properties for this attribute. This method accepts the following types as value parameter: 1. tango.DbDatum - single property data to be inserted 2. tango.DbData - several property data to be inserted 3. sequence<DbDatum> - several property data to be inserted 4. dict<str, DbDatum> - keys are property names and value has data to be inserted 5. dict<str, seq<str>> - keys are property names and value has data to be inserted 6. dict<str, obj> - keys are property names and str(obj) is property value

Parameters:

value:: can be one of the following: 1. tango.DbDatum - single property data to be inserted 2. tango.DbData - several property data to be inserted 3. sequence<DbDatum> - several property data to be inserted 4. dict<str, DbDatum> - keys are property names and value has data to be inserted 5. dict<str, seq<str>> - keys are property names and value has data to be inserted 6. dict<str, obj> - keys are property names and str(obj) is property value

Return:

None

Throws:

ConnectionFailed, CommunicationFailed DevFailed from device (DB_SQLError), TypeError

read(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().read_attribute(self.name(), …)

For convenience, here is the documentation of DeviceProxy.read_attribute(…):

read_attribute(self, attr_name, extract_as=ExtractAs.Numpy, green_mode=None, wait=True, timeout=None) -> DeviceAttribute

Read a single attribute.

Parameters:

attr_name:

(str) The name of the attribute to read.

extract_as:

(ExtractAs) Defaults to numpy.

green_mode:

(GreenMode) Defaults to the current DeviceProxy GreenMode. (see get_green_mode() and set_green_mode()).

wait:

(bool) whether or not to wait for result. If green_mode is Synchronous, this parameter is ignored as it always waits for the result. Ignored when green_mode is Synchronous (always waits).

timeout:

(float) The number of seconds to wait for the result. If None, then there is no limit on the wait time. Ignored when green_mode is Synchronous or wait is False.

Return:

(DeviceAttribute)

Throws:

ConnectionFailed, CommunicationFailed, DevFailed from device TimeoutError (green_mode == Futures) If the future didn’t finish executing before the given timeout. Timeout (green_mode == Gevent) If the async result didn’t finish executing before the given timeout.

Changed in version 7.1.4: For DevEncoded attributes, before it was returning a DeviceAttribute.value as a tuple (format<str>, data<str>) no matter what was the extract_as value was. Since 7.1.4, it returns a (format<str>, data<buffer>) unless extract_as is String, in which case it returns (format<str>, data<str>).

Changed in version 8.0.0: For DevEncoded attributes, now returns a DeviceAttribute.value as a tuple (format<str>, data<bytes>) unless extract_as is String, in which case it returns (format<str>, data<str>). Careful, if using python >= 3 data<str> is decoded using default python utf-8 encoding. This means that PyTango assumes tango DS was written encapsulating string into utf-8 which is the default python encoding.

New in version 8.1.0: green_mode parameter. wait parameter. timeout parameter.

Changed in version 9.4.0: For spectrum and image attributes with an empty sequence, no longer returns DeviceAttribute.value and DeviceAttribute.w_value as None. Instead, DevString and DevEnum types get an empty tuple, while other types get an empty numpy.ndarray. Using extract_as can change the sequence type, but it still won’t be None.

read_asynch(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().read_attribute_asynch(self.name(), …)

For convenience, here is the documentation of DeviceProxy.read_attribute_asynch(…):

read_attribute_asynch(self, attr_name, green_mode=None, wait=True, timeout=None) -> int read_attribute_asynch(self, attr_name, cb, extract_as=Numpy, green_mode=None, wait=True, timeout=None) -> None

Read asynchronously the specified attributes.

New in PyTango 7.0.0

Important

by default, TANGO is initialized with the polling model. If you want to use the push model (the one with the callback parameter), you need to change the global TANGO model to PUSH_CALLBACK. You can do this with the tango.ApiUtil.set_asynch_cb_sub_model()

param attr_name:

an attribute to read

type attr_name:

str

param cb:

push model: as soon as attributes read, core calls cb with read results. This callback object should be an instance of a user class with an attr_read() method. It can also be any callable object.

type cb:

Optional[Callable]

param extract_as:

Defaults to numpy.

type extract_as:

ExtractAs

param green_mode:

Defaults to the current DeviceProxy GreenMode. (see get_green_mode() and set_green_mode()).

type green_mode:

GreenMode

param wait:

whether to wait for result. If green_mode is Synchronous, this parameter is ignored as it always waits for the result.

type wait:

bool

param timeout:

The number of seconds to wait for the result. If None, then there is no limit on the wait time. Ignored when green_mode is Synchronous or wait is False.

type timeout:

float

returns:

an asynchronous call identifier which is needed to get attribute value if poll model, None if push model

rtype:

Union[int, None]

throws:

ConnectionFailed

read_reply(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().read_attribute_reply(…)

For convenience, here is the documentation of DeviceProxy.read_attribute_reply(…):

read_attribute_reply(self, id, extract_as=ExtractAs.Numpy, green_mode=None, wait=True) -> DeviceAttribute read_attribute_reply(self, id, poll_timeout, extract_as=ExtractAs.Numpy, green_mode=None, wait=True) -> DeviceAttribute

Check if the answer of an asynchronous read_attribute is arrived (polling model).

Changed in version 7.0.0: New in PyTango

Changed in version 10.0.0: To eliminate confusion between different timeout parameters, the core (cppTango) timeout (previously the optional second positional argument) has been renamed to “poll_timeout”. Conversely, the pyTango executor timeout remains as the keyword argument “timeout”. These parameters have distinct meanings and units:

The cppTango “poll_timeout” is measured in milliseconds and blocks the call until a reply is received. If the reply is not received within the specified poll_timeout duration, an exception is thrown. Setting poll_timeout to 0 causes the call to wait indefinitely until a reply is received.

The pyTango “timeout” is measured in seconds and is applicable only in asynchronous GreenModes (Asyncio, Futures, Gevent), and only when “wait” is set to True. The specific behavior when a reply is not received within the specified timeout period varies depending on the GreenMode.

param id:

the asynchronous call identifier

type id:

int

param poll_timeout:

cppTango core timeout in ms. If the reply has not yet arrived, the call will wait for the time specified (in ms). If after timeout, the reply is still not there, an exception is thrown. If timeout set to 0, the call waits until the reply arrives. If the argument is not provided, then there is no timeout check, and an exception is raised immediately if the reply is not ready.

type poll_timeout:

Optional[int]

param extract_as:

Defaults to numpy.

type extract_as:

ExtractAs

param green_mode:

Defaults to the current DeviceProxy GreenMode. (see get_green_mode() and set_green_mode()).

type green_mode:

GreenMode

param wait:

whether to wait for result. If green_mode is Synchronous, this parameter is ignored as it always waits for the result.

type wait:

bool

param timeout:

pytango green executor timout. The number of seconds to wait for the result. If None, then there is no limit on the wait time. Ignored when green_mode is Synchronous or wait is False.

type timeout:

float

returns:

If the reply is arrived and if it is a valid reply, it is returned to the caller in a list of DeviceAttribute. If the reply is an exception, it is re-thrown by this call. If the reply is not yet arrived, the call will wait (blocking the process) for the time specified in timeout. If after timeout milliseconds, the reply is still not there, an exception is thrown. If timeout is set to 0, the call waits until the reply arrived.

rtype:

DeviceAttribute

throws:

Union[AsynCall, AsynReplyNotArrived, ConnectionFailed, CommunicationFailed, DevFailed]

set_config(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().set_attribute_config(…)

For convenience, here is the documentation of DeviceProxy.set_attribute_config(…):

set_attribute_config(self, attr_info, green_mode=None, wait=True, timeout=None) -> None set_attribute_config(self, attr_info_ex, green_mode=None, wait=True, timeout=None) -> None

Change the attribute configuration/extended attribute configuration for the specified attribute(s)

param attr_info:

Attribute information. This parameter is used when providing basic attribute(s) information.

type attr_info:

Union[AttributeInfo, Sequence[AttributeInfo]], optional

param attr_info_ex:

Extended attribute information. This parameter is used when providing extended attribute information. It should not be used simultaneously with ‘attr_info’.

type attr_info_ex:

Union[AttributeInfoEx, Sequence[AttributeInfoEx]], optional

param green_mode:

Defaults to the current DeviceProxy GreenMode. Refer to tango.DeviceProxy.get_green_mode and tango.DeviceProxy.set_green_mode for more details.

type green_mode:

GreenMode

param wait:

Specifies whether to wait for the result. If green_mode is Synchronous, this parameter is ignored as the operation always waits for the result. This parameter is also ignored when green_mode is Synchronous.

type wait:

bool

param timeout:

The number of seconds to wait for the result. If set to None, there is no limit on the wait time. This parameter is ignored when green_mode is Synchronous or when wait is False.

type timeout:

float, optional

returns:

None

raises ConnectionFailed:

Raised in case of a connection failure.

raises CommunicationFailed:

Raised in case of a communication failure.

raises DevFailed:

Raised in case of a device failure.

raises TypeError:

Raised in case of an incorrect type of input arguments.

set_transparency_reconnection(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().set_transparency_reconnection(…)

For convenience, here is the documentation of DeviceProxy.set_transparency_reconnection(…):

set_transparency_reconnection(self, yesno) -> None

Set the device transparency reconnection flag

Parameters:

” - val : (bool) True to set transparency reconnection ” or False otherwise

Return:

None

state(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().state(…)

For convenience, here is the documentation of DeviceProxy.state(…): state (self, green_mode=None, wait=True, timeout=None) -> DevState

A method which returns the state of the device.

param green_mode:

Defaults to the current DeviceProxy GreenMode. Refer to tango.DeviceProxy.get_green_mode and tango.DeviceProxy.set_green_mode for more details.

type green_mode:

GreenMode

param wait:

Specifies whether to wait for the result. If green_mode is Synchronous, this parameter is ignored as the operation always waits for the result. This parameter is also ignored when green_mode is Synchronous.

type wait:

bool

param timeout:

The number of seconds to wait for the result. If set to None, there is no limit on the wait time. This parameter is ignored when green_mode is Synchronous or when wait is False.

type timeout:

float, optional

returns:

A DevState constant.

rtype:

DevState

status(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().status(…)

For convenience, here is the documentation of DeviceProxy.status(…): status (self, green_mode=None, wait=True, timeout=None) -> str

A method which returns the status of the device as a string.

param green_mode:

Defaults to the current DeviceProxy GreenMode. Refer to tango.DeviceProxy.get_green_mode and tango.DeviceProxy.set_green_mode for more details.

type green_mode:

GreenMode

param wait:

Specifies whether to wait for the result. If green_mode is Synchronous, this parameter is ignored as the operation always waits for the result. This parameter is also ignored when green_mode is Synchronous.

type wait:

bool

param timeout:

The number of seconds to wait for the result. If set to None, there is no limit on the wait time. This parameter is ignored when green_mode is Synchronous or when wait is False.

type timeout:

float, optional

returns:

string describing the device status

rtype:

str

stop_poll(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().stop_poll_attribute(self.name(), …)

For convenience, here is the documentation of DeviceProxy.stop_poll_attribute(…):

stop_poll_attribute(self, attr_name) -> None

Remove an attribute from the list of polled attributes.

Parameters:

attr_name:

(str) attribute name

Return:

None

subscribe_event(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().subscribe_event(self.name(), …)

For convenience, here is the documentation of DeviceProxy.subscribe_event(…):

subscribe_event(self, event_type, cb, stateless=False, green_mode=None, wait=True, timeout=None) -> int subscribe_event(self, attr_name, event, cb, filters=[], stateless=False, extract_as=Numpy, green_mode=None, wait=True, timeout=None) -> int subscribe_event(self, attr_name, event, queuesize, filters=[], stateless=False, green_mode=None, wait=True, timeout=None) -> int

The client call to subscribe for event reception. In the push model the client implements a callback method which is triggered when the event is received. Filtering is done based on the reason specified and the event type. For example when reading the state and the reason specified is “change” the event will be fired only when the state changes. Events consist of an attribute name and the event reason. A standard set of reasons are implemented by the system, additional device specific reasons can be implemented by device servers programmers.

param attr_name:

The device attribute name which will be sent as an event, e.g., “current”.

type attr_name:

str

param event_type:

The event reason, which must be one of the enumerated values in EventType. This includes: * EventType.CHANGE_EVENT * EventType.PERIODIC_EVENT * EventType.ARCHIVE_EVENT * EventType.ATTR_CONF_EVENT * EventType.DATA_READY_EVENT * EventType.USER_EVENT

type event_type:

EventType

param cb:

Any callable object or an object with a callable “push_event” method.

type cb:

callable

param filters:

A variable list of name, value pairs which define additional filters for events.

type filters:

sequence<str>, optional

param stateless:

When this flag is set to false, an exception will be thrown if the event subscription encounters a problem. With the stateless flag set to true, the event subscription will always succeed, even if the corresponding device server is not running. A keep-alive thread will attempt to subscribe for the specified event every 10 seconds, executing a callback with the corresponding exception at every retry.

type stateless:

bool

param queuesize:

the size of the event reception buffer. The event reception buffer is implemented as a round robin buffer. This way the client can set-up different ways to receive events: * Event reception buffer size = 1 : The client is interested only in the value of the last event received. All other events that have been received since the last reading are discarded. * Event reception buffer size > 1 : The client has chosen to keep an event history of a given size. When more events arrive since the last reading, older events will be discarded. * Event reception buffer size = ALL_EVENTS : The client buffers all received events. The buffer size is unlimited and only restricted by the available memory for the client.

type queuesize:

float, optional

param extract_as:

(Description Needed)

type extract_as:

ExtractAs

param green_mode:

Defaults to the current DeviceProxy GreenMode. See tango.DeviceProxy.get_green_mode and tango.DeviceProxy.set_green_mode for more details.

type green_mode:

GreenMode

param wait:

Specifies whether to wait for the result. If green_mode is Synchronous, this parameter is ignored as the operation always waits for the result. This parameter is also ignored when green_mode is Synchronous.

type wait:

bool

param timeout:

The number of seconds to wait for the result. If set to None, there is no limit on the wait time. This parameter is ignored when green_mode is Synchronous or when wait is False.

type timeout:

float, optional

returns:

An event id which has to be specified when unsubscribing from this event.

rtype:

int

raises EventSystemFailed:

Raised in case of a failure in the event system.

raises TypeError:

Raised in case of an incorrect type of input arguments.

unsubscribe_event(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().unsubscribe_event(…)

For convenience, here is the documentation of DeviceProxy.unsubscribe_event(…):

unsubscribe_event(self, event_id, green_mode=None, wait=True, timeout=None) -> None

Unsubscribes a client from receiving the event specified by event_id.

param event_id:

The event identifier returned by DeviceProxy::subscribe_event(). Unlike in TangoC++, this implementation checks that the event_id has been subscribed to in this DeviceProxy.

type event_id:

int

param green_mode:

Defaults to the current DeviceProxy GreenMode. Refer to tango.DeviceProxy.get_green_mode and tango.DeviceProxy.set_green_mode for more details.

type green_mode:

GreenMode

param wait:

Specifies whether to wait for the result. If green_mode is Synchronous, this parameter is ignored as the operation always waits for the result. This parameter is also ignored when green_mode is Synchronous.

type wait:

bool

param timeout:

The number of seconds to wait for the result. If set to None, there is no limit on the wait time. This parameter is ignored when green_mode is Synchronous or when wait is False.

type timeout:

float, optional

returns:

None

raises EventSystemFailed:

Raised in case of a failure in the event system.

raises KeyError:

Raised if the specified event_id is not found or not subscribed in this DeviceProxy.

write(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().write_attribute(self.name(), …)

For convenience, here is the documentation of DeviceProxy.write_attribute(…):

write_attribute(self, attr_name, value, green_mode=None, wait=True, timeout=None) -> None write_attribute(self, attr_info, value, green_mode=None, wait=True, timeout=None) -> None

Write a single attribute.

Parameters:

attr_name:

(str) The name of the attribute to write.

attr_info:

(AttributeInfo)

value:

The value. For non SCALAR attributes it may be any sequence of sequences.

green_mode:

(GreenMode) Defaults to the current DeviceProxy GreenMode. (see get_green_mode() and set_green_mode()).

wait:

(bool) whether or not to wait for result. If green_mode is Synchronous, this parameter is ignored as it always waits for the result. Ignored when green_mode is Synchronous (always waits).

timeout:

(float) The number of seconds to wait for the result. If None, then there is no limit on the wait time. Ignored when green_mode is Synchronous or wait is False.

Throws:

ConnectionFailed, CommunicationFailed, DeviceUnlocked, DevFailed from device TimeoutError (green_mode == Futures) If the future didn’t finish executing before the given timeout. Timeout (green_mode == Gevent) If the async result didn’t finish executing before the given timeout.

New in version 8.1.0: green_mode parameter. wait parameter. timeout parameter.

write_asynch(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().write_attribute_asynch(…)

For convenience, here is the documentation of DeviceProxy.write_attribute_asynch(…):

write_attributes_asynch(self, attr_name, value, green_mode=None, wait=True, timeout=None) -> int write_attributes_asynch(self, attr_name, value, cb, green_mode=None, wait=True, timeout=None) -> None

Write asynchronously the specified attribute.

Important

by default, TANGO is initialized with the polling model. If you want to use the push model (the one with the callback parameter), you need to change the global TANGO model to PUSH_CALLBACK. You can do this with the tango.ApiUtil.set_asynch_cb_sub_model()

param attr_name:

an attribute to write

type attr_name:

str

param value:

value to write

type value:

Any

param cb:

push model: as soon as attribute written, core calls cb with write results. This callback object should be an instance of a user class with an attr_written() method. It can also be any callable object.

type cb:

Optional[Callable]

param green_mode:

Defaults to the current DeviceProxy GreenMode. (see get_green_mode() and set_green_mode()).

type green_mode:

GreenMode

param wait:

whether to wait for result. If green_mode is Synchronous, this parameter is ignored as it always waits for the result.

type wait:

bool

param timeout:

The number of seconds to wait for the result. If None, then there is no limit on the wait time. Ignored when green_mode is Synchronous or wait is False.

type timeout:

float

returns:

an asynchronous call identifier which is needed to get the server reply if poll model, None if push model

rtype:

Union[int, None]

throws:

ConnectionFailed

write_read(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().write_read_attribute(self.name(), …)

For convenience, here is the documentation of DeviceProxy.write_read_attribute(…):

write_read_attribute(self, attr_name, value, extract_as=ExtractAs.Numpy, green_mode=None, wait=True, timeout=None) -> DeviceAttribute

Write then read a single attribute in a single network call. By default (serialisation by device), the execution of this call in the server can’t be interrupted by other clients.

Parameters:

see write_attribute(attr_name, value)

Return:

A tango.DeviceAttribute object.

Throws:

ConnectionFailed, CommunicationFailed, DeviceUnlocked, DevFailed from device, WrongData TimeoutError (green_mode == Futures) If the future didn’t finish executing before the given timeout. Timeout (green_mode == Gevent) If the async result didn’t finish executing before the given timeout.

New in PyTango 7.0.0

New in version 8.1.0: green_mode parameter. wait parameter. timeout parameter.

write_reply(*args, **kwds)

This method is a simple way to do:: self.get_device_proxy().write_attribute_reply(…)

For convenience, here is the documentation of DeviceProxy.write_attribute_reply(…):

write_attribute_reply(self, id, green_mode=None, wait=True) -> None write_attribute_reply(self, id, poll_timeout, green_mode=None, wait=True) -> None

Check if the answer of an asynchronous write_attributes is arrived (polling model). If the reply is arrived and if it is a valid reply, the call returned. If the reply is an exception, it is re-thrown by this call. An exception is also thrown in case of the reply is not yet arrived.

Changed in version 7.0.0: New in PyTango

Changed in version 10.0.0: To eliminate confusion between different timeout parameters, the core (cppTango) timeout (previously the optional second positional argument) has been renamed to “poll_timeout”. Conversely, the pyTango executor timeout remains as the keyword argument “timeout”. These parameters have distinct meanings and units:

The cppTango “poll_timeout” is measured in milliseconds and blocks the call until a reply is received. If the reply is not received within the specified poll_timeout duration, an exception is thrown. Setting poll_timeout to 0 causes the call to wait indefinitely until a reply is received.

The pyTango “timeout” is measured in seconds and is applicable only in asynchronous GreenModes (Asyncio, Futures, Gevent), and only when “wait” is set to True. The specific behavior when a reply is not received within the specified timeout period varies depending on the GreenMode.

param id:

the asynchronous call identifier

type id:

int

param poll_timeout:

cppTango core timeout in ms. If the reply has not yet arrived, the call will wait for the time specified (in ms). If after timeout, the reply is still not there, an exception is thrown. If timeout set to 0, the call waits until the reply arrives. If the argument is not provided, then there is no timeout check, and an exception is raised immediately if the reply is not ready.

type poll_timeout:

Optional[int]

param extract_as:

Defaults to numpy.

type extract_as:

ExtractAs

param green_mode:

Defaults to the current DeviceProxy GreenMode. (see get_green_mode() and set_green_mode()).

type green_mode:

GreenMode

param wait:

whether to wait for result. If green_mode is Synchronous, this parameter is ignored as it always waits for the result.

type wait:

bool

param timeout:

pytango green executor timout. The number of seconds to wait for the result. If None, then there is no limit on the wait time. Ignored when green_mode is Synchronous or wait is False.

type timeout:

float

returns:

None

rtype:

None

throws:

Union[AsynCall, AsynReplyNotArrived, ConnectionFailed, CommunicationFailed, DevFailed]