Setting a global variable or passing variables between modules

[Akshay-Kalwar]

Dear all sorry if you feel like this is not issue please let me know the solution before closing this issue, I want to understand if in current version can we set global variable through a module or can we pass values between modules or set a reactive value that can be accessed through any modules

[gshotwell]

Can you provide a bit more context about what you're trying to do?

In general with Shiny you want to avoid setting regular global variables because they're not reactive, and as a result downstream components won't rerender when their values change. Because of this Shiny has a construct called a reactive variable which operates like a global variable which preserves reactivity. Here's more on this construct: https://shiny.rstudio.com/py/docs/reactive-values.html

If you have an example of the app you're trying to build I'd be happy to take a look

[Akshay-Kalwar]

Thank you for your response, request you to kindly look at the below example
I want to set a variable in a module and display it in other modules or app.py in ui.output_text_verbatim or other outputs or input elements

app.py
from shiny import App, ui, render, reactive
import mod1

app_ui = ui.page_fluid(
ui.navset_pill_list(
ui.nav("Home", ui.output_text_verbatim("businessDataTest")),
mod1.mod1_ui("initialParameters"),
widths=(2, 10))
)

def server(input, output, session):
mod1.mod1_server("initialParameters")
@output
@render.text
def businessDataTest():
return str(mod1.currentPeriod())

app = App(app_ui, server)

mod1.py
from shiny import module, ui, render, reactive, event
import calendar

monthChoices = list(calendar.month_abbr)[1:]
yearChoices = list(map(str, range(2015, 2024)))

@module.ui
def mod1_ui(label: str = "Mod1"):
return ui.nav(
"Initial Parameter",
ui.input_select("month", "Select Month: ", monthChoices),
ui.input_select("year", "Select Year: ", yearChoices),
ui.input_action_button("updateMonthYear", "Update month & year", style="margin-top: 31px"),
)

@module.server
def mod1_server(input, output, session, starting_value=0):

currentPeriod = reactive.Value("")

@reactive.Effect
@reactive.event(input.updateMonthYear)
def updateMonthYear():
    currentPeriod.set(input.month() + "-" + input.year())

[bartverweire]

Hi,

A module can have a reactive value as its input, and it can also return a reactive value (or a tuple of reactive values).
Now, to really link two instances of (the same or a different) module, you may need to define some reactive values in the server function that initializes the module.

Here's an example:

The module is defined in file mod.py

from shiny import *


@module.ui
def shared_values_ui(name, init_value):
    return ui.TagList(
        ui.h3(name),
        ui.row(
            ui.column(6,ui.tags.label("My Value")),
            ui.column(6,ui.tags.label("Other Value"))
        ),
        ui.row(
            ui.column(6,ui.input_numeric("in_my_value", label=None, value=init_value)),
            ui.column(6,ui.output_text_verbatim("out_other_value"))
        )
    )

@module.server
def shared_values_server(input, output, session, other_value: reactive):

    my_value = reactive.Value(0)

    @output
    @render.text
    def out_other_value():
        return other_value()

    @reactive.Effect
    def update_my_value():
        my_value.set(input.in_my_value())

    return my_value

The ui shows 2 rows and 2 columns.
The first row are labels : "My Value" and "Other Value".
The second row contains an input_numeric to change "My Value" (id : in_my_value) and an output showing the value from another module instance.
The module ui accepts a name (for the title) and an initial value for the input_numeric component.

The server accepts, besides the standard input, output and session, also a reactive value "other_value".
This value is displayed in the output_text_verbatim component (id : "out_other_value")
The server defines a reactive value "my_value", that is updated whenever the input "in_my_value" changes.
This reactive value is then returned as output of the module server function.
(I could also have returned input.in_my_value (without parentheses) as a reactive value.)

This module is used in the main app:

from shiny import *

from mod import *

app_ui = ui.page_fluid(
    ui.h2("Sharing values between module instances"),
    ui.row(
        ui.column(6,shared_values_ui("comp1", "Component 1", 1)),
        ui.column(6,shared_values_ui("comp2", "Component 2", 2))
    )
)


def server(input, output, session):

    value1 = reactive.Value(1)
    value2 = reactive.Value(2)

    sh_value1 = shared_values_server("comp1", value2)
    sh_value2 = shared_values_server("comp2", value1)

    @reactive.Effect
    def update_value1():
        value1.set(sh_value1())

    @reactive.Effect
    def update_value2():
        value2.set(sh_value2())

app = App(app_ui, server)

def main():
    run_app(app)

if __name__ == "__main__":
    main()

In the app_ui, we define a row with 2 columns. Each column contains an instance of our module.
Parameters : the id of the instance and our two user defined parameters name and init_value

In the server part of our app, we first define two reactive values.
These reactive values are used as input for our module servers.

And we add 2 reactive effects : whenever the input of one of the module instances is changed, the corresponding reactive value is set. This triggers the output "out_other_value" in the module server.

We don't really need all the reactive values. The output of the first call to shared_values_server could be used as input for the second call, i.e.

sh_value1 = shared_values_server("comp1", value2)
sh_value2 = shared_values_server("comp2", sh_value1)

But this is only possible for sh_value1. We cannot use sh_value2 in the first call, because the variable is not defined yet.

Hope this makes sense ?

Kind Regards,

Bart

[bartverweire]

@Akshay-Kalwar : in your script, you only need to modify the following :

in mod1.py : return the reactive value from the server function

@module.server
def mod1_server(input, output, session, starting_value=0):

    currentPeriod = reactive.Value("")

    @reactive.Effect
    @reactive.event(input.updateMonthYear)
    def updateMonthYear():
        currentPeriod.set(input.month() + "-" + input.year())

    return currentPeriod   # <-- Return the reactive value

Then in your app.py, assign the return value of the mod server function to a variable (which will be a reactive Value), and use this value in the output function

def server(input, output, session):
    currentPeriod = mod1.mod1_server("initialParameters")  # <--- capture return value in a variable (= reactive Value)

    @output
    @render.text
    def businessDataTest():
        return str(currentPeriod())  # <--- use the reactive Value