Dynamic Nodes? Drop down output selectors, populated dynamically

[theBoredGeordie]

Hi. I am new to Nodezator and I have a question which is a twist on the csv loader question from 2022.

I have a node which loads a file to a pandas dataframe, easy. I then would like a column_selector node with say 10 outputs (col1, col2 etc.). The name of the outputs are fixed (easy again). Now the hard bit, I want each output to have a dropdown menu listing all the columns in the dataframe. So output1 (named col1 ) can output say column "A"s data as a pd.series. The dropdown list content either needs to be dynamically populated when the file is loaded or generated when an update button on the node is used.

Can this be done? If so how, as I cannot find any examples. I cannot use text input boxes to select columns, as the user may not know the column names prior to loading the data. Also the column names could be anything, so cannot be pre defined.

Thank you for any help you can give. I am impressed by Nodezator and its capability.

[KennedyRichard]

Hello, theBoredGeordie,

I'm afraid what you want isn't possible in Nodezator.

I wouldn't mind implementing such dynamic features in Nodezator, as long as it doesn't get in the way of Nodezator's goal of being, as close as possible, a 1:1 visual representation of Python. For instance, in Python, functions always only return a single value/object. Nodes in nodezator can have multiple outputs but it is just a visual representation of what is actually a single object: a dictionary with each key representing an output.

However, it seems to me that, in your case, having such dynamic sockets wouldn't save your users any time. That is, they'd still have to execute the graph once so that this theoretical node with dynamic outputs would display the sockets representing the columns. Only then your users would be able to do anything meaningful with the displayed sockets and would likely have to execute the graph again once those output sockets were connected to other meaningful nodes. Even if instead of dynamic sockets, you had a fixed number of sockets and you could also preselect the contents of the socket using a dropdown menu, like you suggested, the users would still need to execute the graph so the dropdown menu would be populated dynamically anyway.

Because of that, my suggestion is to simply create a node that, upon receiving the data frame, displays the names of the available columns (using dataframe.columns.to_list() to obtain such names). Or perhaps your own custom node that loads and returns a dataframe could instead return a dictionary whose keys contain not only your dataframe but other useful data about it as well. Then the users could execute the graph, check which column names are available, then do something meaningful with them (likely executing the graph more times).

There's an example .ndz file attached below that you can open in Nodezator, demonstrating such suggestions. To execute the graph, you must have pandas installed in the Python instance running Nodezator and an accompanying .csv file that is included in the attachment (you must place it in your home folder, that is, the folder returned by pathlib.Path.home()).
example_ndz_and_accompanying_csv.zip

I hope this helps. Let me know if you need anything else. I might not be always so quick to reply, but I try to do my best.

[theBoredGeordie]

Thank you for the response and sorry for the delay. Sadly displaying the columns is not an option as the user may required data with 1000s of columns. The need for dynamic Nodes is to allow a flow to be used for multiple different data inputs.

I have looked at other options and I am currently working on my own node engine using Dear PyiamGui as the interface. This is not a replacement for Nodezator it is specifically for my own purposes to allow data flexibility.

[KennedyRichard]

Thank you for the response and sorry for the delay

Don't worry it is my pleasure to help when I can.

Sadly displaying the columns is not an option as the user may required data with 1000s of columns. The need for dynamic Nodes is to allow a flow to be used for multiple different data inputs

I understand. It seems to me unfortunately Nodezator is not the right tool for your case then. One of my goals for Nodezator is to make embeddable versions of it for usage in other apps. This way people like you could make your own interface and include node editing only in the parts that you thought would need it. Perhaps this would be more suited to your case, but it is also something that will take a lot of time to implement.

I have looked at other options and I am currently working on my own node engine using Dear PyiamGui as the interface.

That's great. Despite being the creator of a node editor, I understand its strenghts and shortcomings and think people should use what works best for the use case.

Considering your requirements, it does look like you need a library to create your own node interface, rather than an app like Nodezator that simply turns your functions into nodes.

This is not a replacement for Nodezator it is specifically for my own purposes to allow data flexibility.

Haha, don't worry. Even if it was an alternative to Nodezator that wouldn't make me mad or sad.

Each new piece of software, be it an app or a framework/lib, offers a new approach to a problem and this approach may be invaluable for many use cases for which other existing solutions wouldn't be a good fit, including Nodezator.

The more open-source tools we have tackling a problem, the better it is for everyone.

Wish I could be of more help, but I think there's nothing more I can say that might be of use to you.

As always, let me know if you need anything.