The way to create Phrase docs from R or Python with Quarto

quarto pandoc -o my-doc-style.docx   
--print-default-data-file reference.docx

This creates an everyday Phrase .docx file, not a Microsoft Phrase .dotx template. You’ll be able to open your reference .docx and customise its kinds as with all Phrase doc by opening the Types panel from the Phrase ribbon.

To use the template in a Quarto doc, add it to the doc’s YAML header with syntax like this:

format: 
  docx: 
    reference-doc: my-doc-style.docx

There are different customizations obtainable for Quarto Phrase paperwork, comparable to including a desk of contents or part numbering, which you’ll be able to see within the Quarto documentation for Phrase. 

Step 5: Add outcomes of R or Python code to your Phrase doc

Among the best issues about producing a Phrase doc from R or Python is the flexibility to run code and add outcomes to your doc—together with graphics.

You do that by including code chunks to your Quarto file, that are set off by three backticks, like this for R:

```{r}
# R code right here
```

or this for Python:

```{python}
# Python code right here
```

You’ll be able to set choices for a code chunk comparable to whether or not to show the code (echo), run the code (eval), present code warning messages, and so forth. Chunk choices begin off with #| (sometimes called a “hash pipe”) for R, Python, or Julia.

The chunk choices under would present outcomes of R code in a bit however not show the code within the Phrase doc:

```{r}
#| echo: false
#| eval: true
# R code right here
```

Different choices embody #| fig-cap: My caption for a determine caption, #| warning: false to not show any warning messages when code runs, and #| cache: true to cache outcomes of a compute-intensive chunk the place information received’t change.

You’ll be able to execute code throughout the determine caption possibility through the use of !expr with syntax comparable to 

#| fig-cap: !expr paste("Information pulled on"Sys.Date())

Step 6: Render the doc

You’ll be able to render a Quarto doc in RStudio or VS Code through the use of the Render button, the keyboard shortcut Ctrl/Cmd + Shift + Ok or achieve this with the terminal command 

quarto render my_quarto_document.qmd --to docx

for a doc named my_quarto_document.

R customers can even use the quarto R package deal’s command

quarto_render("my_quarto_document")

Be aware: Often, the preliminary Phrase doc preview that popped up from RStudio in early variations didn’t all the time show my graph. That appears to be fastened. Nonetheless, if that occurs to you, attempt duplicating the preliminary .docx file as a brand new, editable Phrase doc, since that fastened the difficulty for me.

Step 7 (non-compulsory): Automate a number of variations with parameters

With the ability to create Phrase information with outcomes of your code is helpful not just for single-time paperwork. It additionally allows you to streamline common information reporting and updates with code that pulls new information from an exterior supply, runs new calculations, and generates up-to-date graphs with a single render name.

However Quarto additionally has the flexibility so as to add parameters to a report, that are like variables outlined externally throughout rendering. That allows you to use a report as a template and create the identical report for various parameters like cities or areas. For instance, for those who wanted to run one report for every of 10 cities, metropolis may very well be outlined as a parameter in your doc’s YAML header, comparable to

---
title: "My Quarto Doc"
params:
metropolis: New York
---

That units a parameter named metropolis with a default worth of New York. You’ll be able to then entry the worth of the town parameter in your R code with params$metropolis, comparable to 

```{r}
#| echo: false
cat("This report is about", params$metropolis)
```

To create a number of studies in R utilizing the identical Quarto doc however completely different values for the parameter, I usually create a perform to render my doc after which use the purrr package deal’s stroll() perform to run my perform on an inventory of things. For instance, if my parameterized Quarto doc is called params_test.qmd with one parameter named metropolis, this may very well be my render perform in R:

render_my_doc <- perform(the_city = "New York", the_doc = "params_test.qmd") {
quarto::quarto_render(enter = the_doc, execute_params = checklist("metropolis" = the_city), 
output_file = paste0("test_", the_city, ".docx"), output_format = "docx")
}

And that is how I’d use my perform to generate three separate paperwork for New York, Chicago, and Los Angeles:

library(purrr)
stroll(checklist("New York", "Chicago", "Los Angeles"), render_my_doc)

Python syntax is a bit completely different and relies on the papermill library. For instance, defining a parameter is finished in a Python code chunk that may appear like

```{python}
#| tags: [parameters]
metropolis = 'Boston'
```

You’ll be able to learn extra about parameterizing Python paperwork within the Quarto Parameters documentation. 

Should you’re thinking about R and extra tips on R, head to the Do Extra With R web page!