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.