onClientConnected in not been called in gxnet Python

I've been stuck for months on this issue and would appreciate your help. I am trying to read meter data that has a dynamic IP address using Gurux Python, following the steps in this document: Gurux.DLMS.DynamicIP. However, there is no example for Python, so I created a server that listens on port 9090. I am receiving data from the meter in the onReceived function, but the onClientConnected function is not being triggered, and I don't know why.

Additionally, the documentation suggests using server.attached(e.getinfo) in onClientConnected, but there is no server.attached in the Python GXNet code. How can I implement this in Python? Also, why is the onClientConnected function not being triggered?

Furthermore, where should I call the readAll function, and what are the necessary steps within this function? Should I first create a client with the correct client/server interface type and password?

Please guide me on how to read and write to my meter with a dynamic IP. If you have any examples in Python, sharing them would be incredibly helpful. I am also including the code I have tried and the responses I have received in the functions for your reference.

Your guidance will be greatly appreciated.

MY server service Code

import threading
from gurux_net import GXNet
from gurux_net.enums import NetworkType
import socket
import threading
from gurux_common.MediaStateEventArgs import MediaStateEventArgs
from gurux_common.TraceEventArgs import TraceEventArgs

class ServerListener:
def onClientConnected(self, sender, e):
print(f"Client {e.info} is connected.")

def onMediaStateChange(self, sender, e):
print(f"Media state changed: {e.state}")

def onReceived(self, sender, e):
print(f"Data received from {e}: {e.data}")

# Define the server setup and listening logic
def setup_server():
server = GXNet(NetworkType.TCP, None, 9090)
server.server = True # Set to server mode

listener = ServerListener()
server.addListener(listener) # Add event listener for connections

server.open() # Open the server to start listening
print("Server is listening...")

try:
while True:
pass # Keep the main thread alive
except KeyboardInterrupt:
print("Server is shutting down.")
server.close()

# Start the server
if __name__ == "__main__":
setup_server()
____________________________________________________

the 2nd approach with i use

import threading
from gurux_net import GXNet
from gurux_net.enums import NetworkType
from gurux_common.MediaStateEventArgs import MediaStateEventArgs
from gurux_common.TraceEventArgs import TraceEventArgs
from gurux_dlms.enums import InterfaceType, Authentication, ObjectType
from gurux_dlms import GXDLMSClient, GXReplyData
from gurux_common.enums import TraceLevel

class ServerListener:
def __init__(self):
self.trace_level = TraceLevel.INFO # Set the default trace level

def onMediaStateChange(self, sender, e):
print(f"Media state changed: {e.state}")

def onReceived(self, sender, e):
print(f"Data received from {e}: {e.data}")
try:
# Create and configure the GXDLMSClient
client = GXDLMSClient(
useLogicalNameReferencing=True,
interfaceType=InterfaceType.WRAPPER,
clientAddress=17,
serverAddress=1,
forAuthentication=Authentication.LOW,
password=b'00000000'
)
print(f"Client configuration: {client}")

# Send and handle AARQ request
reply = GXReplyData()
self.send_aarq_request(client, reply)
print(f"AARQ request sent and AARE response handled successfully: {reply}")

# Retrieve and process profile generics
profileGenerics = client.objects.getObjects(ObjectType.PROFILE_GENERIC)
for pg in profileGenerics:
self.writeTrace("Profile Generic " + str(pg.name) + " Columns:", TraceLevel.INFO)
if pg.canRead(3):
self.read(pg, 3)
if self.trace_level > TraceLevel.WARNING:
sb = ""
for k, _ in pg.captureObjects:
if sb:
sb += " | "
sb += str(k.name)
sb += " "
desc = k.description
if desc:
sb += desc
self.writeTrace(sb, TraceLevel.INFO)
except Exception as ex:
self.writeTrace("Error! Failed to read columns:" + str(ex), TraceLevel.ERROR)
finally:
# Proper resource management should be ensured
print("Cleanup resources if any")

def onClientConnected(self, sender, e):
print(f"Client {e} is connected.")

def onTrace(self, sender, e):
print(f"onTrace {e}")

def onPropertyChanged(self, sender, e):
print(f"onPropertyChanged {e}")

@staticmethod
def send_aarq_request(client, reply):
"""Send AARQ request and handle AARE response."""
try:
reply.clear()
data_list = client.aarqRequest()
if isinstance(data_list, list) and len(data_list) > 0:
data = data_list[0]
print(f"AARQ Request data: {data}")
ServerListener.read_data_block(data, reply)
client.parseAareResponse(reply.data)
print(f"AARE response: {reply}")
reply.clear()

if client.authentication.value > Authentication.LOW.value:
for it in client.getApplicationAssociationRequest():
ServerListener.read_data_block(it, reply)
client.parseApplicationAssociationResponse(reply.data)
except Exception as e:
print(f"Error in AARQ/AARE process: {e}")

@staticmethod
def read_data_block(data, reply):
"""Simulate reading a data block."""
if isinstance(data, (bytearray, bytes)):
if len(data) > 0:
try:
print(f"Data to be set: {data.hex()} (length: {len(data)})")
reply.data.set(data)
print(f"Data block read: {data.hex()}")
except IndexError as e:
print(f"Index error while reading data block: {e}")
print(f"Data length: {len(data)}")
print(f"Data content: {data.hex()}")
except TypeError as e:
print(f"Type error while reading data block: {e}")
else:
print("Received empty data block.")
else:
print("Unexpected data type:", type(data))

def writeTrace(self, message, level):
if level >= self.trace_level:
print(message)

def read(self, object, attribute_index):
# Placeholder method for reading an attribute of an object
print(f"Reading attribute {attribute_index} of object {object.name}")

# Define the server setup and listening logic
def setup_server():
server = GXNet(NetworkType.TCP, None, 9090)
server.server = True # Set to server mode

listener = ServerListener()
# Adding event listener for connections

server.addListener(listener) # Fallback if __netListeners does not exist

print("Attempting to open server...")
server.open() # Open the server to start listening
print("Server is listening...")

try:
while True:
pass # Keep the main thread alive
except KeyboardInterrupt:
print("Server is shutting down.")
server.close()

# Start the server
if __name__ == "__main__":
setup_server()

_________________________________

RESPONSE

root@ip-172-31-44-127:~# python3 GXNET.py
Media state changed: MediaState.OPENING
Media state changed: MediaState.OPEN
Server is listening...
Data received from 182.191.133.110:34816:00 01 00 01 00 11 00 12 DD 10 30 30 30 30 30 30 32 38 39 38 30 30 30 30 31 38 : bytearray(b'\x00\x01\x00\x01\x00\x11\x00\x12\xdd\x100000002898000018')