Is there a way to share data between Python and ObservableJS in the same dashboard?

[schlich]

Description

I love the new dashboards feature!

I have an observable input:

```{ojs}
viewof my_input_variable = Inputs.select(['1'], {label: "MyInputVariable"})
```

and a python output:

```{python}
import foo
foo(my_input_variable).plot()
```

Obviously, my_input_variable is not defined in the python context. Is there any way to get these cells to talk to each other?

[mcanouil]

See https://quarto.org/docs/interactive/ojs/index.html#data-sources.

[cscheid]

Is there a method for the opposite direction?

Think about it: Jupyter executes on your local machine (or on some CI system like GitHub Actions), and OJS runs on (likely someone else's) web browser. What you're suggesting is not possible on a standard setup. In order to do the kind of interactivity you want, you need to switch to something like Shiny for Python.

[schlich]

I'm not sure i follow completely. Why would Shiny be able to interpret an input from a different shiny component and not from a JS component? my understanding was that all of the plotly/shiny/whatever components get "translated" into JS to enable the sorts of reactivity they exhibit but maybe i'm oversimplifying things.. lots of magic happening under the hood here, which of course is what makes Quarto so appealing.

[mcanouil]

Here you are using plain Python which means you need something to run Python, thus, as is, you can't have interactivity without a working Python environment.
Observable.js is a JavaScript library and can run within a browser, thus allowing interactivity without anything else required.

This is why you can't go from one to the other, they don't even live in the same space.
Quarto on rendering allows to pass static object to Observable, which then allows you to interact with that static object, usually a dataset.

Shiny (Python or R) is a web framework design to add interactivity components using Python or R as a server to make the computations.
But this results in the same issue as above on its own, as Shiny requires a Python or R setup to run.
Now comes Web Assembly (https://webassembly.org/), to allow shiny to be ran in the browser, there is shinylive (for Python and webR for R) and the Quarto extension shinylive, that lift the need to have a local R/Python to instead use the browser to make the R/Python computations.
But even with shiny/shinylive, those still lives in a different space/environment that JavaScript/Observable.

See:

• https://shiny.posit.co/py/docs/shinylive.html
• https://github.com/posit-dev/shinylive
• https://github.com/posit-dev/r-shinylive
• https://github.com/quarto-ext/shinylive
• https://quarto.org/docs/interactive/shiny/index.html

[cscheid]

my understanding was that all of the plotly/shiny/whatever components get "translated" into JS

Your confusion comes, I think from what you think "all" means. Plotly cannot, for example, translate your data cleaning with Pandas. Plotly (as a vast simplification) ships a description of the data and visualization as JSON to JavaScript, which then executes a separate code path. Shiny for Python actually cross-compiles all of Python into JS+WebAssembly. It's a big difference.

[schlich]

@cscheid you nailed it. thanks.