Client green modes
You can also change the active global green mode at any time in your program:
>>> from tango import DeviceProxy, GreenMode
>>> from tango import set_green_mode, get_green_mode
>>> get_green_mode()
tango.GreenMode.Synchronous
>>> dev = DeviceProxy("sys/tg_test/1")
>>> dev.get_green_mode()
tango.GreenMode.Synchronous
>>> set_green_mode(GreenMode.Futures)
>>> get_green_mode()
tango.GreenMode.Futures
>>> dev.get_green_mode()
tango.GreenMode.Futures
As you can see by the example, the global green mode will affect any previously
created DeviceProxy
using the default DeviceProxy constructor
parameters.
You can specificy green mode on a DeviceProxy
at creation time.
You can also change the green mode at any time:
>>> from tango.futures import DeviceProxy
>>> dev = DeviceProxy("sys/tg_test/1")
>>> dev.get_green_mode()
tango.GreenMode.Futures
>>> dev.set_green_mode(GreenMode.Synchronous)
>>> dev.get_green_mode()
tango.GreenMode.Synchronous
futures mode
Using concurrent.futures
cooperative mode in PyTango is relatively easy:
>>> from tango.futures import DeviceProxy
>>> dev = DeviceProxy("sys/tg_test/1")
>>> dev.get_green_mode()
tango.GreenMode.Futures
>>> print(dev.state())
RUNNING
The tango.futures.DeviceProxy()
API is exactly the same as the standard
DeviceProxy
. The difference is in the semantics of the methods
that involve synchronous network calls (constructor included) which may block
the execution for a relatively big amount of time.
The list of methods that have been modified to accept futures semantics are,
on the tango.futures.DeviceProxy()
:
Constructor
state()
status()
read_attribute()
write_attribute()
write_read_attribute()
read_attributes()
write_attributes()
ping()
So how does this work in fact? I see no difference from using the standard
DeviceProxy
.
Well, this is, in fact, one of the goals: be able to use a futures cooperation
without changing the API. Behind the scenes the methods mentioned before have
been modified to be able to work cooperatively.
All of the above methods have been boosted with two extra keyword arguments wait and timeout which allow to fine tune the behaviour. The wait parameter is by default set to True meaning wait for the request to finish (the default semantics when not using green mode). If wait is set to True, the timeout determines the maximum time to wait for the method to execute. The default is None which means wait forever. If wait is set to False, the timeout is ignored.
If wait is set to True, the result is the same as executing the
standard method on a DeviceProxy
.
If, wait is set to False, the result will be a
concurrent.futures.Future
. In this case, to get the actual value
you will need to do something like:
>>> from tango.futures import DeviceProxy
>>> dev = DeviceProxy("sys/tg_test/1")
>>> result = dev.state(wait=False)
>>> result
<Future at 0x16cb310 state=pending>
>>> # this will be the blocking code
>>> state = result.result()
>>> print(state)
RUNNING
Here is another example using read_attribute()
:
>>> from tango.futures import DeviceProxy
>>> dev = DeviceProxy("sys/tg_test/1")
>>> result = dev.read_attribute('wave', wait=False)
>>> result
<Future at 0x16cbe50 state=pending>
>>> dev_attr = result.result()
>>> print(dev_attr)
DeviceAttribute[
data_format = tango.AttrDataFormat.SPECTRUM
dim_x = 256
dim_y = 0
has_failed = False
is_empty = False
name = 'wave'
nb_read = 256
nb_written = 0
quality = tango.AttrQuality.ATTR_VALID
r_dimension = AttributeDimension(dim_x = 256, dim_y = 0)
time = TimeVal(tv_nsec = 0, tv_sec = 1383923329, tv_usec = 451821)
type = tango.CmdArgType.DevDouble
value = array([ -9.61260664e-01, -9.65924853e-01, -9.70294813e-01,
-9.74369212e-01, -9.78146810e-01, -9.81626455e-01,
-9.84807087e-01, -9.87687739e-01, -9.90267531e-01,
...
5.15044507e-1])
w_dim_x = 0
w_dim_y = 0
w_dimension = AttributeDimension(dim_x = 0, dim_y = 0)
w_value = None]
gevent mode
Warning
Before using gevent mode please note that at the time of writing this documentation, tango.gevent requires the latest version 1.0 of gevent (which has been released the day before :-P).
Using gevent cooperative mode in PyTango is relatively easy:
>>> from tango.gevent import DeviceProxy
>>> dev = DeviceProxy("sys/tg_test/1")
>>> dev.get_green_mode()
tango.GreenMode.Gevent
>>> print(dev.state())
RUNNING
The tango.gevent.DeviceProxy()
API is exactly the same as the standard
DeviceProxy
. The difference is in the semantics of the methods
that involve synchronous network calls (constructor included) which may block
the execution for a relatively big amount of time.
The list of methods that have been modified to accept gevent semantics are,
on the tango.gevent.DeviceProxy()
:
Constructor
state()
status()
read_attribute()
write_attribute()
write_read_attribute()
read_attributes()
write_attributes()
ping()
So how does this work in fact? I see no difference from using the standard
DeviceProxy
.
Well, this is, in fact, one of the goals: be able to use a gevent cooperation
without changing the API. Behind the scenes the methods mentioned before have
been modified to be able to work cooperatively with other greenlets.
All of the above methods have been boosted with two extra keyword arguments wait and timeout which allow to fine tune the behaviour. The wait parameter is by default set to True meaning wait for the request to finish (the default semantics when not using green mode). If wait is set to True, the timeout determines the maximum time to wait for the method to execute. The default timeout is None which means wait forever. If wait is set to False, the timeout is ignored.
If wait is set to True, the result is the same as executing the
standard method on a DeviceProxy
.
If, wait is set to False, the result will be a
gevent.event.AsyncResult
. In this case, to get the actual value
you will need to do something like:
>>> from tango.gevent import DeviceProxy
>>> dev = DeviceProxy("sys/tg_test/1")
>>> result = dev.state(wait=False)
>>> result
<gevent.event.AsyncResult at 0x1a74050>
>>> # this will be the blocking code
>>> state = result.get()
>>> print(state)
RUNNING
Here is another example using read_attribute()
:
>>> from tango.gevent import DeviceProxy
>>> dev = DeviceProxy("sys/tg_test/1")
>>> result = dev.read_attribute('wave', wait=False)
>>> result
<gevent.event.AsyncResult at 0x1aff54e>
>>> dev_attr = result.get()
>>> print(dev_attr)
DeviceAttribute[
data_format = tango.AttrDataFormat.SPECTRUM
dim_x = 256
dim_y = 0
has_failed = False
is_empty = False
name = 'wave'
nb_read = 256
nb_written = 0
quality = tango.AttrQuality.ATTR_VALID
r_dimension = AttributeDimension(dim_x = 256, dim_y = 0)
time = TimeVal(tv_nsec = 0, tv_sec = 1383923292, tv_usec = 886720)
type = tango.CmdArgType.DevDouble
value = array([ -9.61260664e-01, -9.65924853e-01, -9.70294813e-01,
-9.74369212e-01, -9.78146810e-01, -9.81626455e-01,
-9.84807087e-01, -9.87687739e-01, -9.90267531e-01,
...
5.15044507e-1])
w_dim_x = 0
w_dim_y = 0
w_dimension = AttributeDimension(dim_x = 0, dim_y = 0)
w_value = None]
Note
due to the internal workings of gevent, setting the wait flag to
True (default) doesn’t prevent other greenlets from running in parallel.
This is, in fact, one of the major bonus of working with gevent
when
compared with concurrent.futures
asyncio mode
Asyncio mode is similar to gevent but it uses explicit coroutines. You can compare gevent and asyncio examples.
1import asyncio
2from tango.asyncio import DeviceProxy
3
4
5async def asyncio_example():
6 dev = await DeviceProxy("sys/tg_test/1")
7 print(dev.get_green_mode())
8
9 print(await dev.state())
10
11 # in case of high-level API read has to be awaited
12 print(await dev.long_scalar)
13 print(await dev["long_scalar"])
14 print(await getattr(dev, "long_scalar"))
15
16 # while write executed sync
17 dev.long_scalar = 1
18
19 # for low-level API both read_attribute and write_attribute have to be awaited
20 print(await dev.read_attribute("long_scalar"))
21 await dev.write_attribute("long_scalar", 1)
22
23
24if __name__ == "__main__":
25 asyncio.run(asyncio_example())
Below you can find a TCP server example, which runs in an asynchronous mode and waits for a device’s attribute name from a TCP client, then asks the device for a value and replies to the TCP client.
1"""A simple TCP server for Tango attributes.
2
3It runs on all interfaces on port 8888:
4
5 $ python tango_tcp_server.py
6 Serving on 0.0.0.0 port 8888
7
8It can be accessed using netcat:
9
10 $ ncat localhost 8888
11 >>> sys/tg_test/1/ampli
12 0.0
13 >>> sys/tg_test/1/state
14 RUNNING
15 >>> sys/tg_test/1/nope
16 DevFailed[
17 DevError[
18 desc = Attribute nope is not supported by device sys/tg_test/1
19 origin = AttributeProxy::real_constructor()
20 reason = API_UnsupportedAttribute
21 severity = ERR]
22 ]
23 >>> ...
24"""
25
26import asyncio
27from tango.asyncio import AttributeProxy
28
29
30async def handle_echo(reader, writer):
31 # Write the cursor
32 writer.write(b">>> ")
33 # Loop over client request
34 async for line in reader:
35 request = line.decode().strip()
36 # Get attribute value using asyncio green mode
37 try:
38 proxy = await AttributeProxy(request)
39 attr_value = await proxy.read()
40 reply = str(attr_value.value)
41 # Catch exception if something goes wrong
42 except Exception as exc:
43 reply = str(exc)
44 # Reply to client
45 writer.write(reply.encode() + b"\n" + b">>> ")
46 # Close communication
47 writer.close()
48
49
50async def start_serving():
51 server = await asyncio.start_server(handle_echo, "0.0.0.0", 8888)
52 print("Serving on {} port {}".format(*server.sockets[0].getsockname()))
53 return server
54
55
56async def stop_serving(server):
57 server.close()
58 await server.wait_closed()
59
60
61def main():
62 # Start the server
63 loop = asyncio.get_event_loop()
64 server = loop.run_until_complete(start_serving())
65 # Serve requests until Ctrl+C is pressed
66 try:
67 loop.run_forever()
68 except KeyboardInterrupt:
69 pass
70 # Close the server
71 loop.run_until_complete(stop_serving(server))
72 loop.close()
73
74
75if __name__ == "__main__":
76 main()