# Changes to Asyncio green mode servers

## Deprecation of synchronous methods in Asyncio servers

Historically, the implementation of green modes utilized the basic synchronous PyTango code and tried to convert to asynchronous code (coroutines) on the fly. The main advantage of such an implementation was simpler code maintenance: all changes we make automatically applied to all green modes.

However, with Asyncio mode there is a major problem: to convert all original synchronous methods we used Python’s `asyncio.coroutine` function, which was the first iteration to make coroutines by `asyncio`. Unfortunately, it was deprecated in Python 3.8 and finally removed from Python 3.11.

As the temporary solution we copied the `asyncio.coroutine` code to PyTango. But then the cleaning process of the `asyncio` library continued and for Python 3.12 we had to copy `run_coroutine_threadsafe` and modify it to be able to work with such legacy generator-based coroutines.

Since there is no guarantee that our copied methods will be compatible with new versions of `asyncio` we decided to change how the Asyncio green mode of PyTango is implemented.

Note

Starting from PyTango 10.0.0 all Asyncio servers should be written with coroutine functions.

In other words, use `async def` when defining methods for attribute access (read/write/is allowed), for command access (command/is allowed), and for the “special” methods:

> - `init_device`

> - `delete_device`

> - `dev_state`

> - `dev_status`

> - `read_attr_hardware`

> - `always_executed_hook`

The base `tango.server.Device` class was also modified to use `async def`, so instead of doing `super().<method name>()` calls you must do `await super().<method name>()`.

For example, change code like this:

    class MyDevice(Device):
        green_mode = tango.GreenMode.Asyncio

        def init_device(self):
            super().init_device()
            self._attr = 1.5

        @attribute
        def slow_attr(self) -> float:
            time.sleep(0.5)
            return self._attr

To code like this:

    class MyDevice(Device):
        green_mode = tango.GreenMode.Asyncio

        async def init_device(self):
            await super().init_device()
            self._attr = 1.5

        @attribute
        async def slow_attr(self) -> float:
            await asyncio.sleep(0.5)
            return self._attr

In PyTango 10.0.0 we still preserve option to run legacy servers, with synchronous user functions, but every time server is started you will receive a `DeprecationWarning`.

## New methods for adding and removing dynamic attributes

There are now coroutine functions for adding and removing attributes. Specifically, `async_add_attribute()` and `async_remove_attribute()`. Use these instead of the synchronous versions, as they can prevent deadlocks in certain cases when clients are accessing the device during attribute creation/removal.

For example, change code like this:

    class MyDevice(Device):
        green_mode = tango.GreenMode.Asyncio
        attr_value = None

        @command
        async def add_dyn_attr(self):
            attr = attribute(
                name="dyn_attr",
                dtype=int,
                access=AttrWriteType.READ_WRITE,
                fget=self.read_dyn_attr,
                fset=self.write_dyn_attr,
            )
            self.add_attribute(attr)  # bad **********

        @command
        async def remove_dyn_attr(self):
            self.remove_attribute("dyn_attr")  # bad **********

        async def write_dyn_attr(self, attr):
            self.attr_value = attr.get_write_value()

        async def read_dyn_attr(self, attr):
            return self.attr_value

To code like this:

    class MyDevice(Device):
        green_mode = tango.GreenMode.Asyncio
        attr_value = None

        @command
        async def add_dyn_attr(self):
            attr = attribute(
                name="dyn_attr",
                dtype=int,
                access=AttrWriteType.READ_WRITE,
                fget=self.read_dyn_attr,
                fset=self.write_dyn_attr,
            )
            await self.async_add_attribute(attr)  # good **********

        @command
        async def remove_dyn_attr(self):
            await self.async_remove_attribute("dyn_attr")  # good **********

        async def write_dyn_attr(self, attr):
            self.attr_value = attr.get_write_value()

        async def read_dyn_attr(self, attr):
            return self.attr_value

One exception to this rule, is when you are overriding the standard method, `initialize_dynamic_attributes()`. That method is synchronous, so we cannot use the async versions. Since it is only run at device creation, we avoid the deadlock as clients cannot yet access the attributes.

Code like this does not need to change:

    class MyDevice(Device):
        green_mode = tango.GreenMode.Asyncio
        attr_value = None

        def initialize_dynamic_attributes(self):
            attr = attribute(
                name="dyn_attr",
                dtype=int,
                access=AttrWriteType.READ_WRITE,
                fget=self.read_dyn_attr,
                fset=self.write_dyn_attr,
            )
            self.add_attribute(attr)  # OK, in this method

        async def write_dyn_attr(self, attr):
            self.attr_value = attr.get_write_value()

        async def read_dyn_attr(self, attr):
            return self.attr_value