Why can't I define a connection_lost_callback this way?

[iamthebull]

In my app I subclass asyncua.Client and I am trying to add a connection_lost_callback as follows. When I do it this way then client.connection_lost_callback is always None and thus is never called.

class OPCClient(Client, TaskSupervisor):
	def __init__(
			self, 
			name: str, 
			url: str, 
			timeout: int = 4, 
			watchdog_intervall: int = 1, 
			auto_reconnect: bool = False, 
			reconnect_max_delay: int = 30, 
			reconnect_request_timeout: int = 60, 
			auto_start: bool = True, 
			max_start_attempts: int = -1, 
			retry_delay: float = 1):
		
		Client.__init__(self, url, timeout, watchdog_intervall, auto_reconnect, reconnect_max_delay, reconnect_request_timeout)
		TaskSupervisor.__init__(self, name, auto_start = auto_start, max_start_attempts = max_start_attempts, retry_delay = retry_delay)
		self.subscriptions: OPCSubscriptionRegistry = OPCSubscriptionRegistry(f"{self.name} Subscriptions")
		self.child_tasks: dict[str, asyncio.Task] = {}
		self.uaclient._add_state_listener(self.state_change_callback)

	async def connection_lost_callback(self, exc: Exception):          # this doesn't work
		logger.warning(f"connection lost - {exc} - {self.name}")

	def connection_lost_callback(self, exc: Exception):                # this doesn't work
		logger.warning(f"connection lost - {exc} - {self.name}")

but this does

class OPCClient(Client, TaskSupervisor):
	def __init__( ... ):
		...
		self.connection_lost_callback = self._connection_lost_callback

	async def _connection_lost_callback(self, exc: Exception):
		logger.warning(f"connection lost - {exc} - {self.name}")

I don't understand why in the first case the connection_lost_callback methods are being overwritten to None.

[yudin-s]

This happens because Client.__init__() creates an instance attribute with the same name:

self.connection_lost_callback = None

That instance attribute shadows your subclass method named connection_lost_callback, so later lookup finds None, not the method on your subclass. The reconnect path then checks/calls the instance attribute, so the subclass method is never reached.

Use assignment after super().__init__() instead:

from asyncua import Client

class MyClient(Client):
    def __init__(self, url):
        super().__init__(url)
        self.connection_lost_callback = self._on_connection_lost

    async def _on_connection_lost(self, exc):
        print("connection lost:", exc)

Two details matter:

• give the method a different name, for example _on_connection_lost, so it is not shadowed by the instance attribute;
• make it async def, because the client awaits self.connection_lost_callback(exc).

If this fixes your handler, please mark the answer so others do not run into the subclass-shadowing trap.

[iamthebull]

I thought that by defining a method of the same name connection_lost_callback the Client.connection_lost_callback attribute would be overridden like it would if Client.connection_lost_callback were a method of the same name, but I guess not. I'm assuming because Client.connection_lost_callback is a variable and not a method?

[yudin-s]

Yes, that is the distinction.

In Python, methods on the class are descriptors. If there is no instance attribute with that name, my_client.connection_lost_callback falls through to the class and returns the bound method.

But Client.__init__() writes self.connection_lost_callback = None onto the instance. Instance attributes take precedence over non-data descriptors such as normal methods, so the lookup stops at the instance dictionary and returns None. Your subclass method still exists on the class, but it is hidden by the instance attribute of the same name.

So the two equivalent safe patterns are:

class MyClient(Client):
    def __init__(self, url):
        super().__init__(url)
        self.connection_lost_callback = self._on_connection_lost

    async def _on_connection_lost(self, exc):
        ...

or assign any other async callable:

client.connection_lost_callback = on_connection_lost

The important part is that connection_lost_callback is treated by Client as an instance callback slot, not as an overridable hook method.

[iamthebull]

Understood. Thanks for the detailed answers.