I recently received a question on YouTube about running a Quarto project in GitHub Codespaces. This was new to me, so I did some research (thanks to Mickaël Canouil and others for their help!). The key takeaway is that everything needs to be containerized: Quarto, Jupyter, the Quarto extension, R, Python, etc. Installing the VS Code Quarto extension is not enough. The easiest way to achieve this is by using the quarto-codespaces repository.

1. Fork Mickaël’s quarto-codespaces repo: https://github.com/mcanouil/quarto-codespaces
2. Click the green “Code” button, select “Codespaces,” and then “Create codespace on main.”

3. Click “Authorize” and continue. Creating the codespace may take a few minutes.

4. Once the codespace is ready, clone your Quarto project into it. For example, to clone the water-insecurity-dashboard project, run the following in the terminal:

git clone https://github.com/ivelasq/water-insecurity-dashboard.git

5. Navigate to the project directory: cd water-insecurity-dashboard

6. Create a new Python environment. In the Command Palette (Ctrl+Shift+P or Cmd+Shift+P), select “Python: Create Environment…”. Choose “Venv” and the appropriate Python interpreter. Very importantly, make sure you check the box to install dependencies from requirements.txt.

7. Open your .qmd file (e.g., final.qmd) and click the “Preview” button in the top right.

That’s it! Your Quarto project should now be running in GitHub Codespaces.

Back then, I gave a talk at Why R? called Packages for Using R With Python, Tableau, and Other Tools. One part of the talk was about how R itself isn’t just made up of R.

I adapted this classic blog post by wrathematics to explore the composition of the R 4.1.2 source package. The post features a script that scans the .R, .c, and .f files in the source, then records the language (R, C, or Fortran) and the number of lines of code in each language to a CSV file. Keep in mind, I have almost no knowledge of Shell (and this was pre-ChatGPT days!), so it took me a bit to adapt the original script from 2011.

shell.sh

outdir="./"

rdir="./R-4.1.2" #eg, ~/R-2.13.1/
cd $rdir/src

for rfile in `find . -type f -name *.R`
do
loc=`wc -l $rfile | sed -e 's/ ./,/' -e 's/\/[^/]*\//\//g' -e 's/\/[^/]*\//\//g' -e 's/\/[^/]*\///g' -e 's/\///'`
echo "R,$loc"  >> $outdir/r_source_loc.csv
done

for cfile in `find . -type f -name *.c`
do
loc=`wc -l $cfile | sed -e 's/ ./,/' -e 's/\/[^/]*\//\//g' -e 's/\/[^/]*\//\//g' -e 's/\/[^/]*\///g' -e 's/\///'`
echo "C,$loc"  >> $outdir/r_source_loc.csv
done

for ffile in `find . -type f -name *.f`
do
loc=`wc -l $ffile | sed -e 's/ ./,/' -e 's/\/[^/]*\//\//g' -e 's/\/[^/]*\//\//g' -e 's/\/[^/]*\///g' -e 's/\///'`
echo "Fortran,$loc"  >> $outdir/r_source_loc.csv
done

The script creates a file called r_source_loc.csv. It shows the number of lines by programming language by script in R 4.1.2. We can read it into R:

library(dplyr)
library(stringr)

r_loc <-
  readr::read_table(here::here("til-r", "r-composition", "r_source_loc.csv"),
             col_names = c("language", "lines", "script")) |> 
  mutate(language = case_when(str_detect(language, "R,,") ~ "R",
                              str_detect(language, "C,,") ~ "C",
                              str_detect(language, "Fortran,,") ~ "Fortran"),
         lines = as.numeric(lines)) |> 
  distinct()

head(r_loc)

# A tibble: 6 × 3
  language lines script        
  <chr>    <dbl> <chr>         
1 R           20 .snow2.RR     
2 R            9 .multicore3.RR
3 R           15 .multicore2.RR
4 R           10 .multicore1.RR
5 R           25 .RSeed.R      
6 R           36 .Master.R     

Now, we can visualize the percentage of Core R sourcecode files by language using ggplot2:

library(ggplot2)
library(forcats)

r_loc |> 
  filter(!is.na(language)) |> 
  group_by(language) |> 
  summarise (n = n()) |> 
  mutate(rel.freq =  n / sum(n), accuracy = 0.1) |> 
  ggplot(aes(x = fct_reorder(language, desc(rel.freq)), y = rel.freq, fill = language)) +
  geom_bar(stat = "identity") +
  geom_text(
    aes(label = scales::percent(rel.freq)),
    position = position_dodge(width = 0.9),
    vjust = -0.25,
    size = 4
  ) +
  theme_minimal() +
  labs(title = "Percentage of Core R Sourcecode Files by Language") +
  theme(plot.title = element_text(size = 14),
        axis.title.x = element_blank(),
        axis.title.y = element_blank(),
        axis.text.x = element_text(size = 12),
        axis.text.y = element_blank()) +
  scale_fill_manual(values = c("R" = "#332288", 
                               "C" = "#882255", 
                               "Fortran" = "#44AA99"))

Or, we can visualize the percentage of Core R lines of code by language:

r_loc |> 
  filter(!is.na(language)) |> 
  group_by(language) %>% 
  summarise(sum_lines = sum(lines, na.rm = TRUE)) |> 
  ungroup() |> 
  mutate(percent = sum_lines/sum(sum_lines)) |> 
  ggplot(aes(x = fct_reorder(language, desc(percent)), y = percent, fill = language)) +
  geom_bar(stat = "identity") +
  geom_text(
    aes(label = scales::percent(percent)),
    position = position_dodge(width = 0.9),
    vjust = -0.25,
    size = 4
  )+
  theme_minimal() +
  labs(title = "Percentage of Core R Lines of Code by Language") +
  theme(plot.title = element_text(size = 14),
        axis.title.x = element_blank(),
        axis.title.y = element_blank(),
        axis.text.x = element_text(size = 12),
        axis.text.y = element_blank(),
        legend.position = "none") +
  scale_fill_manual(values = c("R" = "#332288", 
                               "C" = "#882255", 
                               "Fortran" = "#44AA99"))

It’s interesting to see how much goes into making R what it is: an ecosystem built on collaboration across languages and tools (which was the takeaway from the talk!). If you’re curious about R’s source code, give the script a shot!

Like {ggplot2}, plotnine supports the use of custom fonts. To add a custom font:

1import matplotlib.font_manager as fm
import os

2project_dir = os.getcwd()
font_path = os.path.join(project_dir, "Raleway-VariableFont_wght.ttf")
prop = fm.FontProperties(fname=font_path)

p = (
    ggplot(rates_long, aes(x="date", y="rate", color="type"))
    + geom_line()
    + theme(
3        title=element_text(hjust=0, fontproperties=prop),
        text=element_text(fontproperties=prop),
        plot_background=element_rect(fill="white")
    )
)

1

Install matplotlib’s font_manager.

2

Install the custom font on your system, and use the os package to point to the directory with your custom font.

3

Set the font in your plotnine plot using the theme() function.

I posted a plotnine plot on Reddit using the Raleway font (code here):

In Python, you can edit and access environment variables with the os and dotenv packages. Install the dotenv package (you don’t need to install os separately as it is part of the initial Python installation):

Terminal

pip install python-dotenv

In your working directory, create a .env file:

Terminal

touch .env

Open the .env file and add your environment variables using the syntax VAR_NAME="value":

.env

BLS_KEY="12345"

Save the file. Then, import the two packages in your Python script:

script.py

import os
from dotenv import load_dotenv
load_dotenv()

Refer to the environment variable in your Python script using os.environ.get():

script.py

bls_key = os.environ.get("BLS_KEY")

You can test whether it was successfully accessed:

script.py

print(bls_key)

Here’s an example of how I used it in my script:

script.py

for table_id in table_ids:
    bls_key = os.environ.get("BLS_KEY")
    parameters = json.dumps(
        {
            "registrationkey": bls_key,
            "seriesid": [table_id],
            "startyear": "2018",
            "endyear": "2024",
            "calculations": "true",
        }
    )

Be sure to add .env to your .gitignore file if using Git, so that you don’t accidentally upload your secret keys:

.gitignore

.env

GitHub only allows you to push folders that contain something. However, you can use .gitkeep files to make “empty” folders.

First, I created all the folders that I needed.

letters <-
  c("a", "b", "c")

foldernames <-
  paste0("2022/", letters)
  
lapply(foldernames, dir.create, recursive = TRUE)

Next, I navigated to the new “2022” folder and created the .gitkeep files.

cd 2022

find . -type d -empty -not -path "./.git/*" -exec touch {}/.gitkeep

Install the development version:

remotes::install_github('r-lib/asciicast', ref = remotes::github_pull(24)) 

Create a file called nzchar.R with specifications for the GIF and the code to run.

#' Title: Using nzchar
#' Columns: 60
#' Rows: 18

# This is not empty
Sys.getenv("R_LIBS_USER")

# This is empty
Sys.getenv("test")

# This returns TRUE
nzchar(Sys.getenv("R_LIBS_USER"))

# This returns FALSE
nzchar(Sys.getenv("test"))

Create another file that creates the GIF:

#' Title: Using nzchar

src <- "nzchar.R"
cast <- asciicast::record(src)

# <<
# `cast` is an `asciicast` object, which has some metadata and the
# recording itself:
# <<

cast

# <<
# You can write `cast` to a GIF file with the version installed above.
# <<

svg <- tempfile(fileext = "gif")
asciicast::write_gif(cast, svg, theme = "monokai")

Really fun for adding to tweets!

Turns out that across() is only for selecting functions (like summarize() and mutate()). This was announced in dplyr 1.0.4.

You use if_any() vs. if_all() depending if you need to match some vs. all columns.

if_any():

mtcars %>%
  as_tibble() %>%
  mutate(across(everything(), as.integer)) %>%
  filter(if_any(contains("m"), ~ . == 0))

# A tibble: 19 × 11
     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
   <int> <int> <int> <int> <int> <int> <int> <int> <int> <int> <int>
 1    21     6   258   110     3     3    19     1     0     3     1
 2    18     8   360   175     3     3    17     0     0     3     2
 3    18     6   225   105     2     3    20     1     0     3     1
 4    14     8   360   245     3     3    15     0     0     3     4
 5    24     4   146    62     3     3    20     1     0     4     2
 6    22     4   140    95     3     3    22     1     0     4     2
 7    19     6   167   123     3     3    18     1     0     4     4
 8    17     6   167   123     3     3    18     1     0     4     4
 9    16     8   275   180     3     4    17     0     0     3     3
10    17     8   275   180     3     3    17     0     0     3     3
11    15     8   275   180     3     3    18     0     0     3     3
12    10     8   472   205     2     5    17     0     0     3     4
13    10     8   460   215     3     5    17     0     0     3     4
14    14     8   440   230     3     5    17     0     0     3     4
15    21     4   120    97     3     2    20     1     0     3     1
16    15     8   318   150     2     3    16     0     0     3     2
17    15     8   304   150     3     3    17     0     0     3     2
18    13     8   350   245     3     3    15     0     0     3     4
19    19     8   400   175     3     3    17     0     0     3     2

if_all():

mtcars %>%
  as_tibble() %>%
  mutate(across(everything(), as.integer)) %>%
  filter(if_all(contains("am"), ~ . == 0))

# A tibble: 19 × 11
     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
   <int> <int> <int> <int> <int> <int> <int> <int> <int> <int> <int>
 1    21     6   258   110     3     3    19     1     0     3     1
 2    18     8   360   175     3     3    17     0     0     3     2
 3    18     6   225   105     2     3    20     1     0     3     1
 4    14     8   360   245     3     3    15     0     0     3     4
 5    24     4   146    62     3     3    20     1     0     4     2
 6    22     4   140    95     3     3    22     1     0     4     2
 7    19     6   167   123     3     3    18     1     0     4     4
 8    17     6   167   123     3     3    18     1     0     4     4
 9    16     8   275   180     3     4    17     0     0     3     3
10    17     8   275   180     3     3    17     0     0     3     3
11    15     8   275   180     3     3    18     0     0     3     3
12    10     8   472   205     2     5    17     0     0     3     4
13    10     8   460   215     3     5    17     0     0     3     4
14    14     8   440   230     3     5    17     0     0     3     4
15    21     4   120    97     3     2    20     1     0     3     1
16    15     8   318   150     2     3    16     0     0     3     2
17    15     8   304   150     3     3    17     0     0     3     2
18    13     8   350   245     3     3    15     0     0     3     4
19    19     8   400   175     3     3    17     0     0     3     2

Any tidyselect usage is allowable inside if_*() just like inside across(), so they work very similarly.

Thanks to @gvelasq for his explanation.