Is it possible to use components that are dynamically defined in memory?

[beetlescollector]

Hi all. I'm a big fan of ReactPy.

I have a situation where the user interface needs to be generated programmatically in Python.

I've gone through the ReactPy Django tutorial of defining component functions which are imported by HTML templates. I can imagine that it's possible to dynamically generate an HTML template that imports a variety of pre-defined components, and programmatically add further customization via key / value pairs in the HTML template. However, generating a HTML template programmatically doesn't seem like a straightforward thing to do.

So I wonder if the following is possible:

• programmatically define a Python function or class that is only in memory and not written to disk (unlike the components.py file in the tutorial).
• let the HTML template consume this Python function or class that is in memory, as opposed to importing a static Python function from the components.py file on disk. I'm thinking that the HTML template doesn't need to change at all and we can just change the function or class that the HTML template points to (in memory).

Many thanks for your assistance!

[rmorshea]

I think it would be useful to know what you're trying to accomplish. Components that are loaded into templates must indeed be statically defined (unless, as you said you get clever when generating your templates), but inside those components you can have dynamic behavior.

[rmorshea]

What we need is to somehow create a persistent instance of this module, function or class where we can set panel_elements programmatically in Python and then when Django accesses it, it's the same instance and panel_elements retains the same info that was set programmatically in Python.

From what I understand of Django, the panel_elements definition that you're constructing programatically is something that would get passed into Django's function for rendering templates as context. Where that fits in with ReactPy would be here, when you're registering a view function:

from django.shortcuts import render

def index(request):
    panel_elements = get_panel_element_definitions()
    return render(request, "my-template.html", context={"panel_elements": panel_elements})

So in summary, you programatically construct the panel_elements definition, render that in the HTML template as context, use the panel_elements context in your HTML template, turn the panel elements description into the actual view.

[beetlescollector]

@rmorshea this sounds very promising. Thank you so much for your help. I will try it today and report back.

[beetlescollector]

I think this method should work. But it seems that get_panel_element_definitions() still needs to get the UI definitions from a file on disk, e.g. a JSON file. I also thought about importing a module "ui_module" that has a dictionary "ui_data" that can be shared between functions, but Django seems to run it's own Python instance, and when it imports "ui_module", no previously defined information is available.

[rmorshea]

get_panel_element_definitions() still needs to get the UI definitions from a file on disk, e.g. a JSON file

Perhaps there's some detail of your application I'm not aware of, but it seems like get_panel_element_definitions could just call your users code couldn't it? I could imagine wanting to save it as a JSON file for performance reasons though so you don't have to re-run your users code on ever page visit.

[beetlescollector]

Yes you are right, the function could just call the user's code.

The way we are thinking about our platform is that it should be able to host and launch many different applications (for data analysis in science) at the same time, in the same "view". This is because problems in our space of science often require multiple apps to be chained together to solve the particular scientist's problem. Each application requires a different UI that the author of the app would design using Python only. So what we would need is a form of dependency injection of an UI object (in memory) that is derived from the app author's UI definitions, and that object should be consumed by get_panel_element_definitions().
This is in contrast to get_panel_element_definitions()calling a particular function or .py file that it knows about.

I'll look further into how we can solve our problem using the method that you highlighted. Many thanks for your help so far!