# AttributeProxy

class `PyTango.``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:

    > 1. string [in] - single property to be deleted
    > 2. PyTango.DbDatum [in] - single property data to be deleted
    > 3. PyTango.DbData [in] - several property data to be deleted
    > 4. sequence<string> [in]- several property data to be deleted
    > 5. sequence<DbDatum> [in] - several property data to be deleted
    > 6. dict<str, obj> [in] - keys are property names to be deleted (values are ignored)
    > 7. dict<str, DbDatum> [in] - several DbDatum.name are property names to be deleted (keys are ignored)

    Parameters:

    value:

    can be one of the following:
    1. string [in] - single property data to be deleted
    2. PyTango.DbDatum [in] - single property data to be deleted
    3. PyTango.DbData [in] - several property data to be deleted
    4. sequence<string> [in]- several property data to be deleted
    5. sequence<DbDatum> [in] - several property data to be deleted
    6. dict<str, obj> [in] - keys are property names to be deleted (values are ignored)
    7. 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)

  `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) -> AttributeInfoEx

    > > > Return the attribute configuration for a single attribute.

    > > Parameters:

    > > name: | (`str`) attribute name

    > > Return: | (`AttributeInfoEx`) Object containing the attribute information
    > > Throws: | `ConnectionFailed`, `CommunicationFailed`, `DevFailed` from device

    > > Deprecated: use get_attribute_config_ex instead

    > get_attribute_config( self, names) -> `AttributeInfoList`

    > > > Return the attribute configuration for the list of specified attributes. To get all the attributes pass a sequence containing the constant PyTango.:class:constants.AllAttr

    > > Parameters:

    > > names: | (sequence<`str`>) attribute names

    > > Return: | (`AttributeInfoList`) Object containing the attributes information
    > > Throws: | `ConnectionFailed`, `CommunicationFailed`, `DevFailed` from device

    > > Deprecated: use get_attribute_config_ex instead

  `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( 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.

    > > Parameters:

    > > event_id: | (`int`) is the event identifier returned by the DeviceProxy.subscribe_event() method.
    > > callback: | (`callable`) Any callable object or any object with a “push_event” method.
    > > extract_as: | (`ExtractAs`)

    > > Return: | None
    > > Throws: | `EventSystemFailed`
    > > See Also: | subscribe_event

    > > New in PyTango 7.0.0

  `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: | (`PyTango.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. PyTango.DbDatum [in] - single property data to be fetched 4. PyTango.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 PyTango.DbData that will be filled with the property values

    Parameters:

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

    Return: | (`DbData`) containing the property(ies) value(s). If a PyTango.DbData is given as parameter, it returns the same object otherwise a new PyTango.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.

    > > Parameters:

    > > attr_name: | (`str`) attribute name

    > > Return: | boolean value

  `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) -> int

    > > > A method which sends a ping to the device

    > > Parameters: | None
    > > 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. PyTango.DbDatum - single property data to be inserted 2. PyTango.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. PyTango.DbDatum - single property data to be inserted 2. PyTango.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)

  `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>). Carefull, 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.

  `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) -> int read_attribute_asynch( self, attr_name, callback) -> None

    > > > Shortcut to self.read_attributes_asynch([attr_name], cb)

    > > New in PyTango 7.0.0

  `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) -> int read_attribute_reply( self, id, timeout, extract_as) -> None

    > > > Shortcut to self.read_attributes_reply()[0]

    > > New in PyTango 7.0.0

  `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) -> None

    > > > Change the attribute configuration for the specified attribute

    > > Parameters:

    > > attr_info: | (`AttributeInfo`) attribute information

    > > Return: | None
    > > Throws: | `ConnectionFailed`, `CommunicationFailed`, `DevFailed` from device

    > set_attribute_config( self, attr_info_ex) -> None

    > > > Change the extended attribute configuration for the specified attribute

    > > Parameters:

    > > attr_info_ex: | (`AttributeInfoEx`) extended attribute information

    > > Return: | None
    > > Throws: | `ConnectionFailed`, `CommunicationFailed`, `DevFailed` from device

    > set_attribute_config( self, attr_info) -> None

    > > > Change the attributes configuration for the specified attributes

    > > Parameters:

    > > attr_info: | (sequence<`AttributeInfo`>) attributes information

    > > Return: | None
    > > Throws: | `ConnectionFailed`, `CommunicationFailed`, `DevFailed` from device

    > set_attribute_config( self, attr_info_ex) -> None

    > > > Change the extended attributes configuration for the specified attributes

    > > Parameters:

    > > attr_info_ex: | (sequence<`AttributeInfoListEx`>) extended attributes information

    > > Return: | None
    > > Throws: | `ConnectionFailed`, `CommunicationFailed`, `DevFailed` from device

  `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) -> `DevState`

    > > A method which returns the state of the device.

    > Parameters: | None
    > Return: | (`DevState`) constant

    > Example:

    >     dev_st = dev.state()
    >     if dev_st == DevState.ON : ...

  `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) -> `str`

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

    > Parameters: | None
    > Return: | (`str`) describing the device status

  `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, attr_name, event, callback, filters=[], stateless=False, extract_as=Numpy) -> 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.

    > > Parameters:

    > > attr_name: | (`str`) The device attribute name which will be sent as an event e.g. “current”.
    > > event_type: | (`EventType`) Is the event reason and must be on the enumerated values: * EventType.CHANGE_EVENT * EventType.PERIODIC_EVENT * EventType.ARCHIVE_EVENT * EventType.ATTR_CONF_EVENT * EventType.DATA_READY_EVENT * EventType.USER_EVENT
    > > callback: | (`callable`) Is any callable object or an object with a callable “push_event” method.
    > > filters: | (sequence<`str`>) A variable list of name,value pairs which define additional filters for events.

    > > stateless:

    > > (`bool`) When the this flag is set to false, an exception will be thrown when 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. The keep alive thread will try every 10 seconds to subscribe for the specified event. At every subscription retry, a callback is executed which contains the corresponding exception

    > > extract_as: | (`ExtractAs`)

    > > Return: | An event id which has to be specified when unsubscribing from this event.
    > > Throws: | `EventSystemFailed`

    > subscribe_event(self, attr_name, event, queuesize, filters=[], stateless=False ) -> int

    > > The client call to subscribe for event reception in the pull model. Instead of a `callback` method the client has to specify 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.

    > > All other parameters are similar to the descriptions given in the other subscribe_event() version.

  `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) -> None

    > > > Unsubscribes a client from receiving the event specified by event_id.

    > > Parameters:

    > > event_id: | (`int`) is the event identifier returned by the DeviceProxy::subscribe_event(). Unlike in TangoC++ we chech that the event_id has been subscribed in this DeviceProxy.

    > > Return: | None
    > > Throws: | `EventSystemFailed`

  `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, values) -> int write_attributes_asynch( self, values, callback) -> None

    > > > Shortcut to self.write_attributes_asynch([attr_name, value], cb)

    > > New in PyTango 7.0.0

  `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 PyTango.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) -> None

    > > > Check if the answer of an asynchronous write_attribute 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.

    > > Parameters:

    > > id: | (`int`) the asynchronous call identifier.

    > > Return: | None
    > > Throws: | `AsynCall`, `AsynReplyNotArrived`, `CommunicationFailed`, `DevFailed` from device.

    > > New in PyTango 7.0.0

    > write_attribute_reply(self, id, timeout) -> None

    > > > Check if the answer of an asynchronous write_attribute is arrived (polling model). id is the asynchronous call identifier. 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. 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.

    > > Parameters:

    > > id: | (`int`) the asynchronous call identifier.
    > > timeout: | (`int`) the timeout

    > > Return: | None
    > > Throws: | `AsynCall`, `AsynReplyNotArrived`, `CommunicationFailed`, `DevFailed` from device.

    > > New in PyTango 7.0.0