Example code "V2 API Usage" won't run - "no running event loop"

[Jaxom99]

After installing the right versions and inserting my credentials from the EnergyID platform, I try to run the proposed snippet of code (put in the .py file) using :
python3.13 energyid-webhooks.py

And then I could call this script regularly using NodeRED.

But the python command returns an error :

# python3.13 energyid-webhooks.py 
Traceback (most recent call last):
  File "/usr/src/energyid-python/energyid-webhooks.py", line 5, in <module>
    client = WebhookClient(
        provisioning_key="**obfuscated_for_github**",
    ...<4 lines>...
        #reauth_interval=24  # Hours between token refresh
    )
  File "/usr/local/lib/python3.13/site-packages/energyid_webhooks/client_v2.py", line 105, in __init__
    self.session = session or ClientSession()
                              ~~~~~~~~~~~~~^^
  File "/usr/local/lib/python3.13/site-packages/aiohttp/client.py", line 316, in __init__
    loop = loop or asyncio.get_running_loop()
                   ~~~~~~~~~~~~~~~~~~~~~~~~^^
RuntimeError: no running event loop

Am I doing something wrong ? Is this code supposed to be called inside something else ?

Thanks for your insights !

[Molier]

The WebhookClient is asynchronous and must be created and used inside an async function, which is then run with asyncio.run(). Instantiating it directly at the module level causes the 'no running event loop' error.

to fix the script, it must be structured more like the example for the v2 client, and be run async.

import asyncio
from energyid_webhooks import WebhookClient

# Your credentials
#creds

#define async function here
async def main():
    client = WebhookClient(
        provisioning_key=PROVISIONING_KEY,
        client_secret=PROVISIONING_SECRET,
        device_id=DEVICE_ID,
        device_name=DEVICE_NAME,
        # ... other params if needed
    )
    try:
        # Your logic from the README example, e.g.:
        is_claimed = await client.authenticate()
        if not is_claimed:
            claim_info = client.get_claim_info()
            print(f"Claim device at {claim_info['claim_url']} with code {claim_info['claim_code']}")
            return

        # client.update_sensor(...)
        # await client.synchronize_sensors()
        print("Script executed successfully.") # Example output

    finally:
        await client.close()

#very important, run the async function as async
if __name__ == "__main__":
    asyncio.run(main())

This structure ensures the async client operates correctly.

Node-RED Integration:

I have never used Node-RED before myself, but this seems a promising start to use the exec node, let me know how it goes!

1. Configure the exec node:
   • Set the command to something like python3 /path/to/your/energyid-webhooks.py.
   • You can pass arguments from Node-RED to your script if needed, which your Python script can then access using sys.argv.
   • The exec node will run the script each time it's triggered.
2. Script Execution: When Node-RED triggers the exec node, your Python script will run from start to finish. The asyncio.run(main()) call will manage the asynchronous operations within the script.
3. Output/Result:
   • Any output your Python script prints to stdout (e.g., status messages, JSON data) can be captured by the exec node's first output.
   • Errors printed to stderr will go to the second output.
   • The script's exit code is available on the third output (and often combined with the first two).

For your use case, Node-RED's inject node can be used to trigger the exec node at desired intervals, causing your Python script to run, perform its actions (like authenticating and sending data), and then exit. The script itself doesn't need to be continuously running in the background if Node-RED is handling the scheduling of its execution. Ensure the Python script is executable and Node-RED has the necessary permissions to run it. Using the -u flag for python (python3 -u your_script.py) can be helpful to prevent output buffering issues when called from exec nodes."

[Jaxom99]

Thanks for clarifying, I have only basic skills with Python. It works now for the async part 😃

I'll report back for NodeRED, I know the tool quite well, and the path you mention feels right. I just have to parametrize the inputs of your script, and we'll be good to go!

[Molier]

As a basic overview how I would do the NodeRED execution, since the main distinction with some examples we have in the repo is that it would do everything in a one time exec and then exit cleanly. It would not keep running in the background so you have to make sure it gets instantiated and closed everytime:
example pattern:

1. Define an async def main(): function. This will encapsulate the entire logic for one execution run. Inside this function:

   • Initialize your WebhookClient(...).

2. Perform all operations asynchronously using await within a try block:

   • await client.authenticate()
   • (Crucial for Node-RED): Implement logic to get your sensor data. This might involve reading parameters passed from Node-RED to your script (e.g., using sys.argv or reading a temporary file).
   • await client.update_sensor(...) for each sensor you need to report. Remember this method is also async.
   • await client.synchronize_sensors() to send the batch of data.
   • You can print() status messages or results (like JSON) to stdout. Node-RED's exec node can capture this.

3. Ensure the client is always closed using await client.close() in a finally block. This is critical for graceful shutdown and resource cleanup, even if errors occur during the try block.

   async def main():
       client = None # Initialize to None for the finally block
       try:
           client = WebhookClient(...)
           # ... your await calls ...
           print("Data sent successfully!") # Example stdout
       except Exception as e:
           print(f"Error: {e}", file=sys.stderr) # Send errors to stderr
           # Optionally, sys.exit(1) if you want Node-RED to see a non-zero exit code
       finally:
           if client:
               await client.close()

4. Execute the main function at the script's end:

   if __name__ == "__main__":
       asyncio.run(main())

This structure ensures your script initializes, performs its actions, communicates back to Node-RED (via stdout/stderr/exit code), and cleans up properly every time Node-RED calls it.