Previous topic

Server API

Next topic

Device

This Page

High level server API

Server helper classes for writing Tango device servers.

This module provides a high level device server API. It implements TEP1. It exposes an easier API for developing a Tango device server.

Here is a simple example on how to write a Clock device server using the high level API:

import time
from PyTango.server import run
from PyTango.server import Device, DeviceMeta
from PyTango.server import attribute, command


class Clock(Device):
    __metaclass__ = DeviceMeta

    time = attribute()

    def read_time(self):
        return time.time()

    @command(din_type=str, dout_type=str)
    def strftime(self, format):
        return time.strftime(format)


if __name__ == "__main__":
    run((Clock,))

Here is a more complete example on how to write a PowerSupply device server using the high level API. The example contains:

  1. a read-only double scalar attribute called voltage
  2. a read/write double scalar expert attribute current
  3. a read-only double image attribute called noise
  4. a ramp command
  5. a host device property
  6. a port class property
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
from time import time
from numpy.random import random_sample

from PyTango import AttrQuality, AttrWriteType, DispLevel, server_run
from PyTango.server import Device, DeviceMeta, attribute, command
from PyTango.server import class_property, device_property

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

    voltage = attribute()

    current = attribute(label="Current", dtype=float,
                        display_level=DispLevel.EXPERT,
                        access=AttrWriteType.READ_WRITE,
                        unit="A", format="8.4f",
                        min_value=0.0, max_value=8.5,
                        min_alarm=0.1, max_alarm=8.4,
                        min_warning=0.5, max_warning=8.0,
                        fget="get_current", fset="set_current",
                        doc="the power supply current")

    noise = attribute(label="Noise", dtype=((float,),),
                      max_dim_x=1024, max_dim_y=1024,
                      fget="get_noise")

    host = device_property(dtype=str)
    port = class_property(dtype=int, default_value=9788)

    def read_voltage(self):
        self.info_stream("get voltage(%s, %d)" % (self.host, self.port))
        return 10.0

    def get_current(self):
        return 2.3456, time(), AttrQuality.ATTR_WARNING

    def set_current(self, current):
        print("Current set to %f" % current)

    def get_noise(self):
        return random_sample((1024, 1024))

    @command(dtype_in=float)
    def ramp(self, value):
        print("Ramping up...")

if __name__ == "__main__":
    server_run((PowerSupply,))

Pretty cool, uh?

Note

the __metaclass__ statement is mandatory due to a limitation in the boost-python library used by PyTango.

If you are using python 3 you can write instead:

class PowerSupply(Device, metaclass=DeviceMeta)
    pass

Data types

When declaring attributes, properties or commands, one of the most important information is the data type. It is given by the keyword argument dtype. In order to provide a more pythonic interface, this argument is not restricted to the CmdArgType options.

For example, to define a SCALAR DevLong attribute you have several possibilities:

  1. int
  2. ‘int’
  3. ‘int32’
  4. ‘integer’
  5. PyTango.CmdArgType.DevLong
  6. ‘DevLong’
  7. numpy.int32

To define a SPECTRUM attribute simply wrap the scalar data type in any python sequence:

  • using a tuple: (:obj:`int`,) or
  • using a list: [:obj:`int`] or
  • any other sequence type

To define an IMAGE attribute simply wrap the scalar data type in any python sequence of sequences:

  • using a tuple: ((:obj:`int`,),) or
  • using a list: [[:obj:`int`]] or
  • any other sequence type

Below is the complete table of equivalences.

dtype argument converts to tango type
None DevVoid
'None' DevVoid
DevVoid DevVoid
'DevVoid' DevVoid
DevState DevState
'DevState' DevState
bool DevBoolean
'bool' DevBoolean
'boolean' DevBoolean
DevBoolean DevBoolean
'DevBoolean' DevBoolean
numpy.bool_ DevBoolean
'char' DevUChar
'chr' DevUChar
'byte' DevUChar
chr DevUChar
DevUChar DevUChar
'DevUChar' DevUChar
numpy.uint8 DevUChar
'int16' DevShort
DevShort DevShort
'DevShort' DevShort
numpy.int16 DevShort
'uint16' DevUShort
DevUShort DevUShort
'DevUShort' DevUShort
numpy.uint16 DevUShort
int DevLong
'int' DevLong
'int32' DevLong
DevLong DevLong
'DevLong' DevLong
numpy.int32 DevLong
'uint' DevULong
'uint32' DevULong
DevULong DevULong
'DevULong' DevULong
numpy.uint32 DevULong
'int64' DevLong64
DevLong64 DevLong64
'DevLong64' DevLong64
numpy.int64 DevLong64
'uint64' DevULong64
DevULong64 DevULong64
'DevULong64' DevULong64
numpy.uint64 DevULong64
DevInt DevInt
'DevInt' DevInt
'float32' DevFloat
DevFloat DevFloat
'DevFloat' DevFloat
numpy.float32 DevFloat
float DevDouble
'double' DevDouble
'float' DevDouble
'float64' DevDouble
DevDouble DevDouble
'DevDouble' DevDouble
numpy.float64 DevDouble
str DevString
'str' DevString
'string' DevString
'text' DevString
DevString DevString
'DevString' DevString
bytearray DevEncoded
'bytearray' DevEncoded
'bytes' DevEncoded
DevEncoded DevEncoded
'DevEncoded' DevEncoded
DevVarBooleanArray DevVarBooleanArray
'DevVarBooleanArray' DevVarBooleanArray
DevVarCharArray DevVarCharArray
'DevVarCharArray' DevVarCharArray
DevVarShortArray DevVarShortArray
'DevVarShortArray' DevVarShortArray
DevVarLongArray DevVarLongArray
'DevVarLongArray' DevVarLongArray
DevVarLong64Array DevVarLong64Array
'DevVarLong64Array' DevVarLong64Array
DevVarULong64Array DevVarULong64Array
'DevVarULong64Array' DevVarULong64Array
DevVarFloatArray DevVarFloatArray
'DevVarFloatArray' DevVarFloatArray
DevVarDoubleArray DevVarDoubleArray
'DevVarDoubleArray' DevVarDoubleArray
DevVarUShortArray DevVarUShortArray
'DevVarUShortArray' DevVarUShortArray
DevVarULongArray DevVarULongArray
'DevVarULongArray' DevVarULongArray
DevVarStringArray DevVarStringArray
'DevVarStringArray' DevVarStringArray
DevVarLongStringArray DevVarLongStringArray
'DevVarLongStringArray' DevVarLongStringArray
DevVarDoubleStringArray DevVarDoubleStringArray
'DevVarDoubleStringArray' DevVarDoubleStringArray
class PyTango.server.Device(cl, name)

Bases: PyTango._PyTango.Device_4Impl

High level DeviceImpl API. All Device specific classes should inherit from this class.

add_attribute(self, attr, r_meth=None, w_meth=None, is_allo_meth=None) → Attr
Add a new attribute to the device attribute list. Please, note that if you add an attribute to a device at device creation time, this attribute will be added to the device class attribute list. Therefore, all devices belonging to the same class created after this attribute addition will also have this attribute.
Parameters :
attr:(Attr or AttrData) the new attribute to be added to the list.
r_meth:(callable) the read method to be called on a read request
w_meth:(callable) the write method to be called on a write request (if attr is writable)
is_allo_meth:(callable) the method that is called to check if it is possible to access the attribute or not
Return :

(Attr) the newly created attribute.

Throws :

DevFailed

always_executed_hook()

Tango always_executed_hook. Default implementation does nothing

append_status(self, status, new_line=False) → None
Appends a string to the device status.
Parameters:status : (str) the string to be appened to the device status new_line : (bool) If true, appends a new line character before the string. Default is False
Return:None
check_command_exists(self) → None
This method check that a command is supported by the device and does not need input value. The method throws an exception if the command is not defined or needs an input value
Parameters:
cmd_name:(str) the command name
Return:

None

Throws:

DevFailed API_IncompatibleCmdArgumentType, API_CommandNotFound

New in PyTango 7.1.2

debug_stream(self, msg, *args) → None

Sends the given message to the tango debug stream.

Since PyTango 7.1.3, the same can be achieved with:

print(msg, file=self.log_debug)
Parameters :
msg:(str) the message to be sent to the debug stream
Return :

None

dev_state(self) → DevState
Get device state. Default method to get device state. The behaviour of this method depends on the device state. If the device state is ON or ALARM, it reads the attribute(s) with an alarm level defined, check if the read value is above/below the alarm and eventually change the state to ALARM, return the device state. For all th other device state, this method simply returns the state This method can be redefined in sub-classes in case of the default behaviour does not fullfill the needs.
Parameters:None
Return:(DevState) the device state
Throws:DevFailed - If it is necessary to read attribute(s) and a problem occurs during the reading
dev_status(self) → str
Get device status. Default method to get device status. It returns the contents of the device dev_status field. If the device state is ALARM, alarm messages are added to the device status. This method can be redefined in sub-classes in case of the default behaviour does not fullfill the needs.
Parameters:None
Return:(str) the device status
Throws:DevFailed - If it is necessary to read attribute(s) and a problem occurs during the reading
error_stream(self, msg, *args) → None

Sends the given message to the tango error stream.

Since PyTango 7.1.3, the same can be achieved with:

print(msg, file=self.log_error)
Parameters :
msg:(str) the message to be sent to the error stream
Return :

None

fatal_stream(self, msg, *args) → None

Sends the given message to the tango fatal stream.

Since PyTango 7.1.3, the same can be achieved with:

print(msg, file=self.log_fatal)
Parameters :
msg:(str) the message to be sent to the fatal stream
Return :

None

get_attr_min_poll_period(self) → seq<str>
Returns the min attribute poll period
Parameters:None
Return:(seq) the min attribute poll period

New in PyTango 7.2.0

get_attr_poll_ring_depth(self, attr_name) → int
Returns the attribute poll ring depth
Parameters:
attr_name:(str) the attribute name
Return:

(int) the attribute poll ring depth

New in PyTango 7.1.2

get_attribute_poll_period(self, attr_name) → int
Returns the attribute polling period (ms) or 0 if the attribute is not polled.
Parameters:
attr_name:(str) attribute name
Return:

(int) attribute polling period (ms) or 0 if it is not polled

New in PyTango 8.0.0

get_cmd_min_poll_period(self) → seq<str>
Returns the min command poll period
Parameters:None
Return:(seq) the min command poll period

New in PyTango 7.2.0

get_cmd_poll_ring_depth(self, cmd_name) → int
Returns the command poll ring depth
Parameters:
cmd_name:(str) the command name
Return:

(int) the command poll ring depth

New in PyTango 7.1.2

get_command_poll_period(self, cmd_name) → int
Returns the command polling period (ms) or 0 if the command is not polled.
Parameters:
cmd_name:(str) command name
Return:

(int) command polling period (ms) or 0 if it is not polled

New in PyTango 8.0.0

get_dev_idl_version(self) → int
Returns the IDL version
Parameters:None
Return:(int) the IDL version

New in PyTango 7.1.2

get_device_attr(self) → MultiAttribute
Get device multi attribute object.
Parameters:None
Return:(MultiAttribute) the device’s MultiAttribute object
get_device_properties(self, ds_class = None) → None
Utility method that fetches all the device properties from the database and converts them into members of this DeviceImpl.
Parameters :
ds_class:(DeviceClass) the DeviceClass object. Optional. Default value is None meaning that the corresponding DeviceClass object for this DeviceImpl will be used
Return :

None

Throws :

DevFailed

get_exported_flag(self) → bool
Returns the state of the exported flag
Parameters:None
Return:(bool) the state of the exported flag

New in PyTango 7.1.2

get_logger(self) → Logger
Returns the Logger object for this device
Parameters:None
Return:(Logger) the Logger object for this device
get_min_poll_period(self) → int
Returns the min poll period
Parameters:None
Return:(int) the min poll period

New in PyTango 7.2.0

get_name(self) -> (str)
Get a COPY of the device name.
Parameters:None
Return:(str) the device name
get_non_auto_polled_attr(self) → sequence<str>
Returns a COPY of the list of non automatic polled attributes
Parameters:None
Return:(sequence<str>) a COPY of the list of non automatic polled attributes

New in PyTango 7.1.2

get_non_auto_polled_cmd(self) → sequence<str>
Returns a COPY of the list of non automatic polled commands
Parameters:None
Return:(sequence<str>) a COPY of the list of non automatic polled commands

New in PyTango 7.1.2

get_poll_old_factor(self) → int
Returns the poll old factor
Parameters:None
Return:(int) the poll old factor

New in PyTango 7.1.2

get_poll_ring_depth(self) → int
Returns the poll ring depth
Parameters:None
Return:(int) the poll ring depth

New in PyTango 7.1.2

get_polled_attr(self) → sequence<str>
Returns a COPY of the list of polled attributes
Parameters:None
Return:(sequence<str>) a COPY of the list of polled attributes

New in PyTango 7.1.2

get_polled_cmd(self) → sequence<str>
Returns a COPY of the list of polled commands
Parameters:None
Return:(sequence<str>) a COPY of the list of polled commands

New in PyTango 7.1.2

get_prev_state(self) → DevState
Get a COPY of the device’s previous state.
Parameters:None
Return:(DevState) the device’s previous state
get_state(self) → DevState
Get a COPY of the device state.
Parameters:None
Return:(DevState) Current device state
get_status(self) → str
Get a COPY of the device status.
Parameters:None
Return:(str) the device status
info_stream(self, msg, *args) → None

Sends the given message to the tango info stream.

Since PyTango 7.1.3, the same can be achieved with:

print(msg, file=self.log_info)
Parameters :
msg:(str) the message to be sent to the info stream
Return :

None

init_device()

Tango init_device method. Default implementation calls get_device_properties()

initialize_dynamic_attributes()

Method executed at initializion phase to create dynamic attributes. Default implementation does nothing. Overwrite when necessary.

is_device_locked(self) → bool
Returns if this device is locked by a client
Parameters:None
Return:(bool) True if it is locked or False otherwise

New in PyTango 7.1.2

is_polled(self) → bool
Returns if it is polled
Parameters:None
Return:(bool) True if it is polled or False otherwise

New in PyTango 7.1.2

push_archive_event(self, attr_name) → None

push_archive_event (self, attr_name, except) -> None

push_archive_event (self, attr_name, data, dim_x = 1, dim_y = 0) -> None

push_archive_event (self, attr_name, str_data, data) -> None

push_archive_event (self, attr_name, data, time_stamp, quality, dim_x = 1, dim_y = 0) -> None

push_archive_event (self, attr_name, str_data, data, time_stamp, quality) -> None

Push an archive event for the given attribute name. The event is pushed to the notification daemon.
Parameters:
attr_name:(str) attribute name
data:the data to be sent as attribute event data. Data must be compatible with the attribute type and format. for SPECTRUM and IMAGE attributes, data can be any type of sequence of elements compatible with the attribute type
str_data:(str) special variation for DevEncoded data type. In this case ‘data’ must be a str or an object with the buffer interface.
except:(DevFailed) Instead of data, you may want to send an exception.
dim_x:(int) the attribute x length. Default value is 1
dim_y:(int) the attribute y length. Default value is 0
time_stamp:(double) the time stamp
quality:(AttrQuality) the attribute quality factor
Throws:

DevFailed If the attribute data type is not coherent.

push_att_conf_event(self, attr) → None
Push an attribute configuration event.
Parameters:(Attribute) the attribute for which the configuration event will be sent.
Return:None

New in PyTango 7.2.1

push_change_event(self, attr_name) → None

push_change_event (self, attr_name, except) -> None

push_change_event (self, attr_name, data, dim_x = 1, dim_y = 0) -> None

push_change_event (self, attr_name, str_data, data) -> None

push_change_event (self, attr_name, data, time_stamp, quality, dim_x = 1, dim_y = 0) -> None

push_change_event (self, attr_name, str_data, data, time_stamp, quality) -> None

Push a change event for the given attribute name. The event is pushed to the notification daemon.

Parameters:
attr_name:(str) attribute name
data:the data to be sent as attribute event data. Data must be compatible with the attribute type and format. for SPECTRUM and IMAGE attributes, data can be any type of sequence of elements compatible with the attribute type
str_data:(str) special variation for DevEncoded data type. In this case ‘data’ must be a str or an object with the buffer interface.
except:(DevFailed) Instead of data, you may want to send an exception.
dim_x:(int) the attribute x length. Default value is 1
dim_y:(int) the attribute y length. Default value is 0
time_stamp:(double) the time stamp
quality:(AttrQuality) the attribute quality factor
Throws:

DevFailed If the attribute data type is not coherent.

push_data_ready_event(self, attr_name, counter = 0) → None

Push a data ready event for the given attribute name. The event is pushed to the notification daemon.

The method needs only the attribue name and an optional “counter” which will be passed unchanged within the event

Parameters:
attr_name:(str) attribute name
counter:(int) the user counter
Return:

None

Throws:

DevFailed If the attribute name is unknown.

push_event(self, attr_name, filt_names, filt_vals) → None

push_event (self, attr_name, filt_names, filt_vals, data, dim_x = 1, dim_y = 0) -> None

push_event (self, attr_name, filt_names, filt_vals, str_data, data) -> None

push_event (self, attr_name, filt_names, filt_vals, data, time_stamp, quality, dim_x = 1, dim_y = 0) -> None

push_event (self, attr_name, filt_names, filt_vals, str_data, data, time_stamp, quality) -> None

Push a user event for the given attribute name. The event is pushed to the notification daemon.
Parameters:
attr_name:(str) attribute name
filt_names:(sequence<str>) the filterable fields name
filt_vals:(sequence<double>) the filterable fields value
data:the data to be sent as attribute event data. Data must be compatible with the attribute type and format. for SPECTRUM and IMAGE attributes, data can be any type of sequence of elements compatible with the attribute type
str_data:(str) special variation for DevEncoded data type. In this case ‘data’ must be a str or an object with the buffer interface.
dim_x:(int) the attribute x length. Default value is 1
dim_y:(int) the attribute y length. Default value is 0
time_stamp:(double) the time stamp
quality:(AttrQuality) the attribute quality factor
Throws:

DevFailed If the attribute data type is not coherent.

read_attr_hardware(self, attr_list) → None
Read the hardware to return attribute value(s). Default method to implement an action necessary on a device to read the hardware involved in a a read attribute CORBA call. This method must be redefined in sub-classes in order to support attribute reading
Parameters:
attr_list : (sequence<int>) list of indices in the device object attribute vector

of an attribute to be read.

Return:

None

Throws:

DevFailed This method does not throw exception but a redefined method can.

register_signal(self, signo) → None
Register a signal. Register this device as device to be informed when signal signo is sent to to the device server process
Parameters:
signo:(int) signal identifier
Return:

None

remove_attribute(self, attr_name) → None
Remove one attribute from the device attribute list.
Parameters :
attr_name:(str) attribute name
Return :

None

Throws :

DevFailed

set_archive_event(self, attr_name, implemented, detect=True) → None
Set an implemented flag for the attribute to indicate that the server fires archive events manually, without the polling to be started. If the detect parameter is set to true, the criteria specified for the archive event are verified and the event is only pushed if they are fullfilled. If detect is set to false the event is fired without any value checking!
Parameters:
attr_name:(str) attribute name
implemented:(bool) True when the server fires change events manually.
detect:(bool) Triggers the verification of the change event properties when set to true. Default value is true.
Return:

None

set_change_event(self, attr_name, implemented, detect=True) → None
Set an implemented flag for the attribute to indicate that the server fires change events manually, without the polling to be started. If the detect parameter is set to true, the criteria specified for the change event are verified and the event is only pushed if they are fullfilled. If detect is set to false the event is fired without any value checking!
Parameters:
attr_name:(str) attribute name
implemented:(bool) True when the server fires change events manually.
detect:(bool) Triggers the verification of the change event properties when set to true. Default value is true.
Return:

None

set_state(self, new_state) → None
Set device state.
Parameters:
new_state:(DevState) the new device state
Return:

None

set_status(self, new_status) → None
Set device status.
Parameters:
new_status:(str) the new device status
Return:

None

signal_handler(self, signo) → None
Signal handler. The method executed when the signal arrived in the device server process. This method is defined as virtual and then, can be redefined following device needs.
Parameters:
signo:(int) the signal number
Return:

None

Throws:

DevFailed This method does not throw exception but a redefined method can.

stop_polling(self) → None

stop_polling (self, with_db_upd) -> None

Stop all polling for a device. if the device is polled, call this method before deleting it.
Parameters:
with_db_upd:(bool) Is it necessary to update db ?
Return:

None

New in PyTango 7.1.2

unregister_signal(self, signo) → None
Unregister a signal. Unregister this device as device to be informed when signal signo is sent to to the device server process
Parameters:
signo:(int) signal identifier
Return:

None

warn_stream(self, msg, *args) → None

Sends the given message to the tango warn stream.

Since PyTango 7.1.3, the same can be achieved with:

print(msg, file=self.log_warn)
Parameters :
msg:(str) the message to be sent to the warn stream
Return :

None

write_attr_hardware(self) → None
Write the hardware for attributes. Default method to implement an action necessary on a device to write the hardware involved in a a write attribute. This method must be redefined in sub-classes in order to support writable attribute
Parameters:
attr_list : (sequence<int>) list of indices in the device object attribute vector

of an attribute to be written.

Return:

None

Throws:

DevFailed This method does not throw exception but a redefined method can.

class PyTango.server.attribute(fget=None, **kwargs)

Declares a new tango attribute in a Device. To be used like the python native property function. For example, to declare a scalar, PyTango.DevDouble, read-only attribute called voltage in a PowerSupply Device do:

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

    voltage = attribute()

    def read_voltage(self):
        return 999.999

The same can be achieved with:

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

    @attribute
    def voltage(self):
        return 999.999

It receives multiple keyword arguments.

parameter type default value description
name str class member name alternative attribute name
dtype object DevDouble data type (see Data type equivalence)
dformat AttrDataFormat SCALAR data format
max_dim_x int 1 maximum size for x dimension (ignored for SCALAR format)
max_dim_y int 0 maximum size for y dimension (ignored for SCALAR and SPECTRUM formats)
display_level DispLevel OPERATOR display level
polling_period int -1 polling period
memorized bool False attribute should or not be memorized
hw_memorized bool False write method should be called at startup when restoring memorize value (dangerous!)
access AttrWriteType READ read only/ read write / write only access
fget (or fread) str or callable ‘read_<attr_name>’ read method name or method object
fset (or fwrite) str or callable ‘write_<attr_name>’ write method name or method object
is_allowed str or callable ‘is_<attr_name>_allowed’ is allowed method name or method object
label str ‘<attr_name>’ attribute label
doc (or description) str ‘’ attribute description
unit str ‘’ physical units the attribute value is in
standard_unit str ‘’ physical standard unit
display_unit str ‘’ physical display unit (hint for clients)
format str ‘6.2f’ attribute representation format
min_value str None minimum allowed value
max_value str None maximum allowed value
min_alarm str None minimum value to trigger attribute alarm
max_alarm str None maximum value to trigger attribute alarm
min_warning str None minimum value to trigger attribute warning
max_warning str None maximum value to trigger attribute warning
delta_val str None  
delta_t str None  
abs_change str None minimum value change between events that causes event filter to send the event
rel_change str None minimum relative change between events that causes event filter to send the event (%)
period str None  
archive_abs_change str None  
archive_rel_change str None  
archive_period str None  

Note

avoid using dformat parameter. If you need a SPECTRUM attribute of say, boolean type, use instead dtype=(bool,).

Example of a integer writable attribute with a customized label, unit and description:

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

    current = attribute(label="Current", unit="mA", dtype=int,
                        access=AttrWriteType.READ_WRITE,
                        doc="the power supply current")

    def init_device(self):
        Device.init_device(self)
        self._current = -1

    def read_current(self):
        return self._current

    def write_current(self, current):
        self._current = current

The same, but using attribute as a decorator:

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

    def init_device(self):
        Device.init_device(self)
        self._current = -1

    @attribute(label="Current", unit="mA", dtype=int)
    def current(self):
        """the power supply current"""
        return 999.999

    @current.write
    def current(self, current):
        self._current = current

In this second format, defining the write implies setting the attribute access to READ_WRITE.

PyTango.server.command(f=None, dtype_in=None, dformat_in=None, doc_in='', dtype_out=None, dformat_out=None, doc_out='')

Declares a new tango command in a Device. To be used like a decorator in the methods you want to declare as tango commands. The following example declares commands:

  • void TurnOn(void)
  • void Ramp(DevDouble current)
  • DevBool Pressurize(DevDouble pressure)
class PowerSupply(Device):
    __metaclass__ = DeviceMeta

    @command
    def TurnOn(self):
        self.info_stream('Turning on the power supply')

    @command(dtype_in=float)
    def Ramp(self, current):
        self.info_stream('Ramping on %f...' % current)

    @command(dtype_in=float, doc_in='the pressure to be set',
             dtype_out=bool, doc_out='True if it worked, False otherwise')
    def Pressurize(self, pressure):
        self.info_stream('Pressurizing to %f...' % pressure)

Note

avoid using dformat parameter. If you need a SPECTRUM attribute of say, boolean type, use instead dtype=(bool,).

Parameters:
  • dtype_in – a data type describing the type of parameter. Default is None meaning no parameter.
  • dformat_in (AttrDataFormat) – parameter data format. Default is None.
  • doc_in (str) – parameter documentation
  • dtype_out – a data type describing the type of return value. Default is None meaning no return value.
  • dformat_out (AttrDataFormat) – return value data format. Default is None.
  • doc_out (str) – return value documentation
class PyTango.server.device_property(dtype, doc='', default_value=None)

Declares a new tango device property in a Device. To be used like the python native property function. For example, to declare a scalar, PyTango.DevString, device property called host in a PowerSupply Device do:

from PyTango.server import Device, DeviceMeta
from PyTango.server import device_property

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

    host = device_property(dtype=str)
Parameters:
  • dtype – Data type (see Data types)
  • doc – property documentation (optional)
  • default_value – default value for the property (optional)
class PyTango.server.class_property(dtype, doc='', default_value=None)

Declares a new tango class property in a Device. To be used like the python native property function. For example, to declare a scalar, PyTango.DevString, class property called port in a PowerSupply Device do:

from PyTango.server import Device, DeviceMeta
from PyTango.server import class_property

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

    port = class_property(dtype=int, default_value=9788)
Parameters:
  • dtype – Data type (see Data types)
  • doc – property documentation (optional)
  • default_value – default value for the property (optional)
PyTango.server.run(classes, args=None, msg_stream=<open file '<stdout>', mode 'w' at 0x7f19895e61e0>, verbose=False, util=None, event_loop=None, post_init_callback=None, green_mode=None)

Provides a simple way to run a tango server. It handles exceptions by writting a message to the msg_stream.

The classes parameter can be either a sequence of:

or a dictionary where:

  • key is the tango class name

  • value is either:

The optional post_init_callback can be a callable (without arguments) or a tuple where the first element is the callable, the second is a list of arguments (optional) and the third is a dictionary of keyword arguments (also optional).

Note

the order of registration of tango classes defines the order tango uses to initialize the corresponding devices. if using a dictionary as argument for classes be aware that the order of registration becomes arbitrary. If you need a predefined order use a sequence or an OrderedDict.

Example 1: registering and running a PowerSupply inheriting from Device:

from PyTango.server import Device, DeviceMeta, run

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

run((PowerSupply,))

Example 2: registering and running a MyServer defined by tango classes MyServerClass and MyServer:

from PyTango import Device_4Impl, DeviceClass
from PyTango.server import run

class MyServer(Device_4Impl):
    pass

class MyServerClass(DeviceClass):
    pass

run({'MyServer': (MyServerClass, MyServer)})

Example 3: registering and running a MyServer defined by tango classes MyServerClass and MyServer:

from PyTango import Device_4Impl, DeviceClass
from PyTango.server import Device, DeviceMeta, run

class PowerSupply(Device):
    __metaclass__ = DeviceMeta

class MyServer(Device_4Impl):
    pass

class MyServerClass(DeviceClass):
    pass

run([PowerSupply, [MyServerClass, MyServer]])
# or: run({'MyServer': (MyServerClass, MyServer)})
Parameters:
  • classes (sequence or dict) – a sequence of Device classes or a dictionary where keyword is the tango class name and value is a sequence of Tango Device Class python class, and Tango Device python class
  • args (list) – list of command line arguments [default: None, meaning use sys.argv]
  • msg_stream – stream where to put messages [default: sys.stdout]
  • util (Util) – PyTango Util object [default: None meaning create a Util instance]
  • event_loop (callable) – event_loop callable
  • post_init_callback (callable or tuple (see description above)) – an optional callback that is executed between the calls Util.server_init and Util.server_run
Returns:

The Util singleton object

Return type:

Util

New in version 8.1.2.

Changed in version 8.1.4: when classes argument is a sequence, the items can also be a sequence <TangoClass, TangoClassClass>[, tango class name]

PyTango.server.server_run(classes, args=None, msg_stream=<open file '<stdout>', mode 'w' at 0x7f19895e61e0>, verbose=False, util=None, event_loop=None, post_init_callback=None, green_mode=None)

Since PyTango 8.1.2 it is just an alias to run(). Use run() instead.

New in version 8.0.0.

Changed in version 8.0.3: Added util keyword parameter. Returns util object

Changed in version 8.1.1: Changed default msg_stream from stderr to stdout Added event_loop keyword parameter. Returns util object

Changed in version 8.1.2: Added post_init_callback keyword parameter

Deprecated since version 8.1.2: Use run() instead.