Forem: João Palmeiro

How to change a tooltip to dark theme in Altair?

João Palmeiro — Sun, 27 Mar 2022 16:37:26 +0000

When we add a tooltip to a chart in Altair, as in the example below, it follows a light theme by default. This tooltip implementation comes from Vega Tooltip, a plugin included in Vega-Embed (the package used under the hood to render the charts).

import altair as alt
import pandas as pd

source = pd.DataFrame(
    {
        "a": ["A", "B", "C", "D", "E", "F", "G", "H", "I"],
        "b": [28, 55, 43, 91, 81, 53, 19, 87, 52],
    }
)

alt.Chart(source).mark_bar(tooltip=True).encode(x="a", y="b")

In addition to the light theme, Vega Tooltip also has another predefined theme: the dark theme. To use the dark theme, let's set one of the Vega-Embed options to do so, similar to when we configured Vega-Embed for a single Altair chart:

metadata = {"embedOptions": {"tooltip": {"theme": "dark"}}}

Now, considering the chart we created at the beginning, we just need to pass the dictionary defined above as an argument to the properties() method:

alt.Chart(source).mark_bar(tooltip=True).encode(x="a", y="b").properties(
    usermeta=metadata
)

As a result, the tooltip will look like this:

On the other hand, to enable the dark theme globally for all charts in a notebook, for example, it is a matter of running the following snippet initially:

alt.renderers.set_embed_options(tooltip={"theme": "dark"})

Finally, if you have any questions or suggestions, feel free to leave a comment below!

A chart walks into a bar: Altair vs. leather

João Palmeiro — Sat, 26 Mar 2022 20:47:40 +0000

In this blog post series, we're going to compare two Data Visualization packages in the Python landscape. We will create a bar chart from dummy data, based on this example available in the Altair documentation, with each package. Furthermore, we will try to follow the most straightforward implementation to compare the two APIs/charts from their defaults.

For this first installment, let's create a bar chart using Altair and then leather. The dataset looks like this:

import pandas as pd

source = pd.DataFrame(
    {
        "a": ["A", "B", "C", "D", "E", "F", "G", "H", "I"],
        "b": [28, 55, 43, 91, 81, 53, 19, 87, 52],
    }
)

From the source above, we can define a bar chart in Altair via the following snippet:

import altair as alt

alt.Chart(source).mark_bar().encode(x="a", y="b")

When we run the snippet above, we get the result below:

Now, using leather, we get a similar bar chart as follows:

import leather

chart = leather.Chart()

# We cannot use a pandas DataFrame directly.
chart.add_columns(data=source.to_records(index=False).tolist())

chart.to_svg()

Comparing the two (default) outputs, we can highlight a number of differences:

The default width is larger with leather. As a result, the bars are also wider.
In leather, the bars are red (#e41a1c), compared to blue in Altair.
The bar chart created with leather does not show titles for the axes, unlike Altair.
There is no axis line on the Y-axis in leather. On the X-axis, the labels are not rotated (0°).
In Altair, there are only horizontal gridlines. In the case of leather, there are horizontal and vertical ones.
The default fonts are different. In leather, Monaco is used.
The background colors are also different. In Altair, the background color is white, while in leather, it is a (very) light gray (#f9f9f9).

On the other hand, for the Y-axis, both charts present a scale with the same domain, ending in a nice round value (100). However, the number of ticks is different.

Finally, if you have any questions or suggestions, feel free to leave a comment below!

How do people package Altair themes? (II)

João Palmeiro — Sun, 20 Mar 2022 17:51:03 +0000

After we saw four examples in the first part, let's look at four more and learn more about how people package Altair themes.

Based on the altair-latimes package, we have altair-reveal. In this package, we can find the Reveal theme for Altair. An interesting detail in this theme is the empty space available at the bottom of each chart (bottom padding) to accommodate manually added sources and credits. We can see this detail, as well as several examples, from this notebook directly on GitHub.

For the Sun Sentinel theme, there is sunsentinel_theme. This theme is based on husky_theme, and for us to use it, we have to follow the steps mentioned in the first part (it is not a pip installable Python package).

Based on spaCy branding, we can find two themes in the spacy-altair-theme package. One of them is a monospaced version of the available base theme. In addition to a function for each of the themes (each function contains some constants and returns a dictionary with the configuration for the respective theme), we can also find three importable lists for the three types of defined color palettes. To use these themes, we just need to alt.themes.enable() the desired one, as these are alt.themes.register()ed when we import the package. As a final note, some color variants were chosen from spaCy's style guide because of contrast (like dark blue and dark green instead of blue and green, respectively).

In the case of the pcolor package (bootstrapped from the nbdev template), we can find an Altair (and seaborn) theme for personal use. This package contains color constants and various utilities, in addition to the typical function for the theme (pulsifi_theme). It also provides a utility function called setup_altair() that wraps up theme registration and activation.

Finally, if you have any questions or suggestions, feel free to leave a comment below!

How to configure Vega-Embed for a single Altair chart?

João Palmeiro — Wed, 02 Mar 2022 22:57:08 +0000

By default, in the upper right corner of each Altair chart, there is a dropdown menu with various options. This menu comes with Vega-Embed, the package used under the hood to render the charts.

The Vega-Embed menu can be customized differently for each chart. For this example, we will define a menu with only the options to export the chart as PNG or SVG. Also, the default name of the generated file will be "bar_chart" instead of "visualization", and we will increase the resolution for the PNG image. So, let's see how we can do it using the properties() method and the usermeta argument!

First of all, let's define a dictionary with all the necessary metadata:

metadata = {
    "embedOptions": {
        "actions": {
            "export": True,
            "source": False,
            "compiled": False,
            "editor": False,
        },
        "i18n": {"SVG_ACTION": "Export as SVG", "PNG_ACTION": "Export as PNG"},
        "scaleFactor": 5,
        "downloadFileName": "bar_chart",
    }
}

To keep only the items to export the chart, we start by removing the remaining ones (setting them to False) from the menu. Second, we renamed these items to "Export as SVG" and "Export as PNG", respectively (i18n). Third and fourth, specifically for exporting the chart as PNG, we changed the resolution scale factor from 1 to 5 (scaleFactor) and chose "bar_chart" (without the file extension) as our new default filename (downloadFileName). For more details on these items and other options, check the README file in the Vega-Embed repository.

Now, assuming we already have a chart (like the one in this example available in the Altair documentation), we pass the dictionary defined earlier as an argument to the properties() method:

alt.Chart(source).mark_bar().encode(x="a", y="b").properties(usermeta=metadata)

If you want to adapt this example to a compound chart, make sure you use the properties() method on the "final chart" and not on each of the "intermediate charts":

alt.hconcat(
    alt.Chart(source).mark_bar().encode(x="a", y="b"),
    alt.Chart(source).mark_bar().encode(x="a", y="b"),
).properties(usermeta=metadata)

Finally, if you have any questions or suggestions, feel free to leave a comment below!

How do people package Altair themes?

João Palmeiro — Thu, 24 Feb 2022 19:44:37 +0000

In Altair, we can create custom and shareable themes to apply to different charts. So, several Python packages are available with these themes ready to go. Considering four examples, let's see how other people package their Altair themes. For more information before we talk about them, check the Altair Themes section available in the documentation.

As a first example, we have the altair-latimes package. Here we can find the Los Angeles Times theme for Altair. More specifically, in addition to the theme() function that contains some constants and returns a dictionary with the configuration for the theme, there is a color dictionary (palette). This color dictionary can also be imported and used directly.

For a theme based on the University of Washington brand, there is husky_theme. To leverage it, we need to run the respective file as a script or add it to a given project (and import the husky_theme() function), as opposed to installing and importing a Python package. Like the first example, the husky_theme() function contains some constants and returns a dictionary.

In the hueniversitypy (great name!) package, we can find different themes based on the visual identities of Canadian universities. Each theme is defined in its file, similar to the previous examples (a function with some constants and which returns a dictionary). The main difference between this package and the previous examples is that it brings together more than one theme that can be used separately (instead of being dedicated to a single theme).

To use any of the themes available in the three examples mentioned above globally, we need to alt.themes.register() and alt.themes.enable() them. In the case of the carbonplan-styles package, which provides a light theme and a dark theme for Altair and Matplotlib, we just need to enable the theme (and we don't need to import any extras). In other words, there is no need to register the theme, as it is added to the available themes "automatically" from the entry points defined in the setup.py file (or equivalent):

from setuptools import setup

ENTRY_POINTS = {
    "altair.vegalite.v4.theme": [
        "carbonplan_dark = carbonplan_styles.altair:dark",
        "carbonplan_light = carbonplan_styles.altair:light",
    ],
}

setup(name="carbonplan-styles", entry_points=ENTRY_POINTS)

As for the Altair themes themselves, there is a color dictionary for each one (colors.py file), importable constants for the fonts, and a function for each theme, defined from a more general function (altair.py file).

Finally, if you have any questions or suggestions, feel free to leave a comment below!

Generate a directory structure diagram with mermaid on GitLab.

João Palmeiro — Sun, 22 Dec 2019 01:47:39 +0000

Recently, while preparing the README file for a project hosted on GitLab, I came across the possibility of using mermaid to generate diagrams from markdown-like text. This gave me the idea of trying to recreate the tree-like diagram obtained from the tree -L 2 command.

The tree-like format was not fully preserved (the root appears as the leftmost element, but not at the top, and the reading of the elements is not as vertical, for example), but the result, made as simple as I could, was interesting, as you can see here. Also, there are a few points to keep in mind:

The diagram (a.k.a. flowchart) generated with mermaid takes up more space than the diagram generated with the tree -L 2 command. In addition, if the purpose of this diagram is merely to provide an overview of the directory structure of a given project, obtaining it with mermaid may require extra effort that has no clear benefit.
With the help of style features, you can use the color, for example, of subgraph boundaries (stroke) to encode whether a group of elements concerns a folder or not. This information is already encoded to some extent in the indentation or vertical positioning but may be useful, for example, to separate subgroups of files under the same helper text from other files at the same hierarchical level.
The use of subgraphs for individual files, as in the case of the README file, is because they have a title. This way each file may also have a helper text.
The default placement of titles, as well as the "boxes" of each subgraph, can help, in my opinion, the user to quickly associate a particular helper text with the corresponding elements.
At the interaction level, it is possible to associate a hyperlink with each node (check the root and the README file, please). On the other hand, you can select text from this diagram and copy it easily.

Finally, if you want to know more about mermaid or GitLab Flavored Markdown, you can check out the links. I hope this quick sharing can be helpful to you!