Interactive visualizations with user-specified querying and general notes about public-facing implementations

[sgbaird]

by @ancarnevali

I am now working on a class for plotting a ds containing battery cells information. I would like to make it modular, so that the user can plot what they are interested in by using class methods rather than doing ds filtering with pandas. Something like using class methods to plot eg "all cells with voltage between 3 and 4 V", provided that each entry of the ds is a cell with a defined voltage.

There are a few ways I might tackle the problem of interactive plots with user-defined filtering criteria, based on what I understood from the question.

Plotly and Notebooks

• Use plotly so that users can interact directly with the plots (e.g. by zooming in to the voltage range of 3-4 assuming 3-4 is one of the axes)
  • This could also take the form of plotly dropdowns or sliders. I haven't done much by way of implementation (excited to try it out), but I've certainly appreciated some nice implementations by others (specifically within Ax, see the examples in https://ax.dev/tutorials/visualizations.html and if you see a type of dropdown you like you can look at the source code for the plotting function.
  • You can expose the interactive figures via Jupyter notebooks or by embedding them in (free) webpages/documentation/etc. The former is pretty straightforward (just save the .ipynb file or give someone a Google Colab link to the notebook on GitHub). Let me know if you need help with the latter.
  • You can also use ipywidgets (e.g. sliders) which can be used in Jupyter notebooks. I don't know a ton about these.
  • Last thing maybe worth mentioning is Google Colab Forms (credit to Rhys Goodall for pointing these out at one point).

kwargs and functions

• Include some easy, predefined kwargs for the user in each of the plotting functions. For example, voltage_range with a default of None that doesn't apply constraints to the voltage, and [3,4] if you want between 3 and 4 Volts.
• In addition to specific kwargs (e.g. voltage_range), include a kwarg that allows users to pass arbitrary constraints to e.g. df.query instead of just the ones you hard-coded. Requires some more logic, such as whether to throw an error if the voltage_range is specified directly and in the arbitrary kwarg or whether to prefer one or the other. Here's a mat_discover example (around this line and after, for CrabNet, HDBSCAN*, DensMAP, etc.)
• It's usually more work, but some users might appreciate having standalone plotting functions that double as class methods. mat_discover has a mix of "hard-coded" plotting functions (i.e. you'd have to modify the class attributes and know which ones to modify) and "standalone" plotting functions that can be used without instantiating the class.

Classes

Since you mentioned classes (and maybe you've seen this already or already know the content) figured it was worth mentioning Taylor's lecture on Python classes. Btw, not suggesting all of the above necessarily, just a bunch of ideas that come to mind.

GUIs

A lot of the above comments can mimic the functionality of GUIs/standalone applications without the steeper learning curve, but since you mentioned GUIs, just as a future reference thing, thought it might be worth mentioning flask. Also, nanoHUB's support of Rappture. Here's an example of what I believe is a Rappture tool. I've gotten pretty partial to the idea of using Colab Notebooks for lots of GUI and non-GUI like public-facing "try me" style implementations.

Hope this helps! Let me know if I missed something or if you have follow-up questions. Obviously, this is a lot, so don't feel like you have to look into every single thing I mentioned.

[ancarnevali]

very comprehensive outlook, thank you!

let's say we have something like:

class TheClass:
    def funct_1(self, df):
        --> plot something according to the passed kwargs
    def funct_2(self, df):
        --> plot something else according to the passed kwargs

and we want to introduce kwargs as plotting options.

Is there any recommended, best-practice way to introduce them? Like, would you suggest passing them to the class itself and then have the functions "look" at them to decide how to behave, or just pass specific kwargs to each function?

The first method seems more tidy, but the second a little more logical, as the user can think of the plotting "options" after calling the plotting function. I would result in many more lines of code though, so more room for errors.

[sgbaird]

Going off the major libraries (plotly and matplotlib) their plotting functions usually don't involve class instantiation, but rather passing kwargs into the functions themselves, so maybe that's part of the best practices? Something else I forgot to mention that I think is important is providing a way to access the figure objects (plotly or matplotlib) so the users can customize the figures themselves with full control if they need. Things like fig.update_layout for example.

I think it's also worth mentioning that a minimalist approach, implementing what's most convenient for your purposes, works well esp. when you're the primary user.