### Install and Build Extension

Source: https://github.com/mwouts/jupytext/blob/main/jupyterlab/packages/jupyterlab-jupytext-extension/ui-tests/README.md

Commands to install dependencies and build the extension in production mode. Ensure the extension is installed in JupyterLab before proceeding.

```sh
jlpm install
jlpm build:prod
```

--------------------------------

### Develop Jupytext Extension: Setup and Build

Source: https://github.com/mwouts/jupytext/blob/main/jupyterlab/packages/jupyterlab-jupytext-extension/README.md

Commands to set up a development environment for the jupyterlab-jupytext extension. This includes installing development dependencies, linking the extension, and starting a watch process.

```bash
pip install -e '.[dev]'
cd jupyterlab/packages/jupyterlab-jupytext-extension
jlpm
jlpm install:extension     # Symlink into {sys.prefix}/share/jupyter/labextensions
```

--------------------------------

### Install Pre-commit Hooks

Source: https://github.com/mwouts/jupytext/blob/main/docs/developing.md

Installs the pre-commit framework, which automatically runs code formatting and linting checks before each commit.

```bash
pre-commit install
```

--------------------------------

### Install Calysto Scheme

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/Reference Guide for Calysto Scheme.md

Install Calysto Scheme using pip3. The `--user` flag installs it for the current user, while system-wide installation requires sudo.

```bash
pip3 install --upgrade calysto-scheme --user -U
python3 -m calysto_kernel install --user
```

```bash
sudo pip3 install --upgrade calysto-scheme -U
sudo python3 -m calysto_kernel install
```

--------------------------------

### Perform Addition in Python

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_py/jupyter.ipynb

Demonstrates basic variable assignment and addition. Ensure Python is installed and the environment is set up for execution.

```python
a = 1
b = 2
a + b
```

--------------------------------

### Install UI Test Dependencies

Source: https://github.com/mwouts/jupytext/blob/main/jupyterlab/packages/jupyterlab-jupytext-extension/ui-tests/README.md

Commands to install the necessary dependencies for UI testing, including Playwright browser binaries. This is typically needed only once.

```sh
cd ./ui-tests
jlpm install
jlpm playwright install
cd ..
```

--------------------------------

### Print Hello World in Wolfram Language

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_wolfram/wolfram.ipynb

Use Print to display simple text output. This is a basic starting point for any Wolfram Language script.

```wolfram
Print["Hello, World!"];
```

--------------------------------

### C++11 Constructors Example

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_cpp/xcpp_by_quantstack.ipynb

Demonstrates C++11 constructors (default, copy, and move) for a class 'Foo11'.

```cpp
class Foo11
{
public:
    
    Foo11() { std::cout << "Foo11 default constructor" << std::endl; }
    Foo11(const Foo11&) { std::cout << "Foo11 copy constructor" << std::endl; }
    Foo11(Foo11&&) { std::cout << "Foo11 move constructor" << std::endl; }
};

```

```cpp
Foo11 f1;
Foo11 f2(f1);
Foo11 f3(std::move(f1));
```

--------------------------------

### Install ThreadJob Module

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/script_to_ipynb/build.ipynb

Checks if the ThreadJob module is available and installs version 1.1.2 for the current user if it is not found.

```powershell
# Install ThreadJob if not available
$threadJob = Get-Module ThreadJob -ListAvailable
if ($null -eq $threadjob) {
    Install-Module ThreadJob -RequiredVersion 1.1.2 -Scope CurrentUser -Force
}
```

--------------------------------

### Install Node.js with Conda

Source: https://github.com/mwouts/jupytext/blob/main/docs/developing.md

Installs Node.js version 20 or higher using Conda, a prerequisite for some Jupytext development installations.

```bash
conda install 'nodejs>=20' -c conda-forge
```

--------------------------------

### Commented-out Example (Modulo)

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_coconut/coconut_homepage_demo.ipynb

A commented-out example showing the modulo operation, likely intended as a placeholder or for future use.

```coconut
# 5 `mod` 3 == 2
```

--------------------------------

### Initialize Stata Kernel

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/stata_notebook.md

This comment indicates the use of the stata_kernel for running Stata code in a Jupyter Notebook. Ensure the stata_kernel is installed.

```stata
// This notebook uses the stata_kernel: https://github.com/kylebarron/stata_kernel
```

--------------------------------

### Install Jupytext Notebook Extension

Source: https://github.com/mwouts/jupytext/blob/main/docs/install.md

Install and enable the Jupytext nbextension for classic Jupyter Notebook (versions 6.x and below). Use [--user] for user-specific installation.

```bash
jupyter nbextension install --py jupytext [--user]
```

```bash
jupyter nbextension enable --py jupytext [--user]
```

--------------------------------

### Percent Format Notebook Example

Source: https://github.com/mwouts/jupytext/blob/main/README.md

This is an example of a Python notebook in the `py:percent` format, which uses a `.py` extension. It's suitable for version control and editing in IDEs.

```python
# %% [markdown]
# This is a markdown cell

# %% 
def f(x):
  return 3*x+1

```

--------------------------------

### Commented-out Example (Pattern Matching on Tuples)

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_coconut/coconut_homepage_demo.ipynb

A commented-out example showing pattern matching on a tuple, likely for extracting elements from a sequence.

```coconut
# (| first_elem() |) :: rest_elems()
```

--------------------------------

### Example jupytext-config Session

Source: https://github.com/mwouts/jupytext/blob/main/docs/text-notebooks.md

Demonstrates a typical workflow for managing default viewers using the `jupytext-config` command-line tool, including setting, inspecting, and unsetting viewers.

```bash
# starting from the default config of JupyterLab
$ jupytext-config list-default-viewer
# we add the default viewer for 2 doctypes
$ jupytext-config set-default-viewer python markdown
# we check what was done
$ jupytext-config list-default-viewer
python: Jupytext Notebook
markdown: Jupytext Notebook
# we can now remove the default viewer for markdown
$ jupytext-config unset-default-viewer markdown
# and check again
$ jupytext-config list-default-viewer
python: Jupytext Notebook
$

```

--------------------------------

### Commented-out Example (Function Composition)

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_coconut/coconut_homepage_demo.ipynb

A commented-out example illustrating function composition, likely for demonstrating a more advanced functional concept.

```coconut
# (f..g..h)(x, y, z)
```

--------------------------------

### Install Development Version from GitHub

Source: https://github.com/mwouts/jupytext/blob/main/docs/developing.md

Use this command to install a development version of Jupytext directly from its GitHub repository. Requires Node.js.

```bash
HATCH_BUILD_HOOKS_ENABLE=true pip install git+https://github.com/mwouts/jupytext.git
```

--------------------------------

### Multiple Format Specifications (jupytext.toml - Tutorials)

Source: https://github.com/mwouts/jupytext/blob/main/docs/config.md

Define multiple pairing configurations in jupytext.toml. This example pairs tutorial notebooks to markdown and Python scripts, while other notebooks pair only to Python scripts.

```toml
# jupytext.toml

# Tutorial notebooks get paired to markdown docs
[[formats]]
"notebooks/tutorials/" = "ipynb"
"docs/tutorials/" = "md"
"scripts/tutorials/" = "py:percent"

# Default pairing: all other notebooks are paired with Python scripts
[[formats]]
"notebooks/" = "ipynb"
"scripts/" = "py:percent"
```

--------------------------------

### Print Hello World in Python

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/raw_cell_with_non_dict_yaml_content.md

A basic Python code snippet to print 'Hello, World!' to the console. This is often used as a first example.

```python
print("Hello, World!")
```

--------------------------------

### Install Jupytext with Pip

Source: https://github.com/mwouts/jupytext/blob/main/README.md

Install Jupytext in your Python environment using pip.

```bash
pip install jupytext
```

--------------------------------

### Start JupyterLab Server for Test Generation

Source: https://github.com/mwouts/jupytext/blob/main/jupyterlab/packages/jupyterlab-jupytext-extension/ui-tests/README.md

Command to start the JupyterLab server, which is required before using the Playwright code generator.

```sh
cd ./ui-tests
jlpm start
```

--------------------------------

### Install Jupytext Extension for JupyterLab 1.x

Source: https://github.com/mwouts/jupytext/blob/main/docs/install.md

Install a specific version of the jupyterlab-jupytext extension compatible with JupyterLab 1.x.

```bash
jupyter labextension install jupyterlab-jupytext@1.1.1
```

--------------------------------

### Light Format Example with Markdown and Code Cells

Source: https://github.com/mwouts/jupytext/blob/main/docs/formats-scripts.md

Demonstrates the light format, where comments adjacent to code are Markdown cells and blank lines separate cells.

```python
# This is a multiline
# Markdown cell

# Another Markdown cell


# This is a code cell
class A():
    def one():
        return 1

    def two():
        return 2
```

--------------------------------

### Install Jupytext Extension for JupyterLab 2.x

Source: https://github.com/mwouts/jupytext/blob/main/docs/install.md

Install a specific version of the jupyterlab-jupytext extension compatible with JupyterLab 2.x.

```bash
jupyter labextension install jupyterlab-jupytext@1.2.2
```

--------------------------------

### Install Development Branch from GitHub

Source: https://github.com/mwouts/jupytext/blob/main/docs/developing.md

Installs a specific development branch from Jupytext's GitHub repository. Replace 'branch' with the desired branch name. Requires Node.js.

```bash
HATCH_BUILD_HOOKS_ENABLE=true pip install git+https://github.com/mwouts/jupytext.git@branch
```

--------------------------------

### Percent Format Example with Markdown and Code Cells

Source: https://github.com/mwouts/jupytext/blob/main/docs/formats-scripts.md

Illustrates the percent format with explicit markdown and code cells.

```python
# %% [markdown]
# This is a multiline
# Markdown cell

# %% [markdown]
# Another Markdown cell


# %% 
# This is a code cell
class A():
    def one():
        return 1

    def two():
        return 2
```

--------------------------------

### Install Jupytext Extension for JupyterLab 3.x

Source: https://github.com/mwouts/jupytext/blob/main/docs/install.md

Install a specific version of the jupyterlab-jupytext extension compatible with JupyterLab 3.x.

```bash
jupyter labextension install jupyterlab-jupytext@1.3.11
```

--------------------------------

### Install SOS-notebook and related packages

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_sos/jupytext_replication.ipynb

Installs a specific version of R and the necessary SOS-notebook, jupyterlab-sos, and sos-papermill packages. Use this command when encountering compatibility issues with the latest R version.

```bash
conda install -c r r=3.5.1
conda install sos-notebook jupyterlab-sos sos-papermill -c conda-forge
```

--------------------------------

### Import Libraries and Configure Pandas

Source: https://github.com/mwouts/jupytext/blob/main/demo/World population.myst.md

Imports necessary libraries (pandas, wbdata) and sets display options for pandas DataFrames. Ensure these libraries are installed.

```python
import pandas as pd
import wbdata as wb

pd.options.display.max_rows = 6
pd.options.display.max_columns = 20
```

--------------------------------

### Install Jupytext in Development Mode

Source: https://github.com/mwouts/jupytext/blob/main/docs/developing.md

Installs the Jupytext package in editable mode, allowing for immediate use of local changes. Includes development dependencies.

```bash
HATCH_BUILD_HOOKS_ENABLE=true pip install -e '.[dev]'
```

--------------------------------

### Multiple Format Specifications (jupytext.toml - Mixed Formats)

Source: https://github.com/mwouts/jupytext/blob/main/docs/config.md

Configure Jupytext with multiple, distinct format specifications. This example pairs tutorial notebooks to markdown, example notebooks to MyST format, and all others to Python scripts.

```toml
# jupytext.toml

# Tutorial notebooks
[[formats]]
"notebooks/tutorials/" = "ipynb"
"docs/tutorials/" = "md"

# Example notebooks with MyST format
[[formats]]
"notebooks/examples/" = "ipynb"
"docs/examples/" = "md:myst"

# Default for all other notebooks
[[formats]]
"notebooks/" = "ipynb"
"scripts/" = "py:percent"
```

--------------------------------

### Define Macro Syntax

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_scheme/Reference Guide for Calysto Scheme.ipynb

Use define-syntax to create custom macros. This example defines a 'time' macro to measure execution time.

```scheme
(define-syntax time 
  [(time ?exp) (let ((start (current-time))) 
                 ?exp 
                 (- (current-time) start))])
```

```scheme
(time (car '(1 2 3 4)))
```

--------------------------------

### Define Audio Rich Display

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_cpp/xcpp_by_quantstack.ipynb

Implement mime_bundle_repr for a custom audio type to enable rich rendering. This example sets the 'text/html' MIME type for audio playback.

```cpp
#include <string>
#include <fstream>

#include "xtl/xbase64.hpp"
#include "xeus/xjson.hpp"

namespace au
{
    struct audio
    {
        inline audio(const std::string& filename)
        {
            std::ifstream fin(filename, std::ios::binary);   
            m_buffer << fin.rdbuf();
        }
        
        std::stringstream m_buffer;
    };
    
    xeus::xjson mime_bundle_repr(const audio& a)
    {
        auto bundle = xeus::xjson::object();
        bundle["text/html"] =
           std::string("<audio controls=\"controls\"><source src=\"data:audio/wav;base64,")
           + xtl::base64encode(a.m_buffer.str()) +
            
```

--------------------------------

### GoNB Init and Main Execution Order

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_go/hello_world_gonb.ipynb

Illustrates the execution order in GoNB where an 'init' function is called before the main execution block.

```go
func init_a() {
    fmt.Println("init_a")
}
%% 
fmt.Println("main")
```

--------------------------------

### Iterate and Get File Size in Xonsh

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_xonsh/xonsh_example.ipynb

Iterate through hidden files (starting with '.') using shell globbing and print each filename. Then, use `du -sh` to display the disk usage for each file. This is helpful for analyzing file sizes in a directory.

```xonsh
for filename in `.*`:
    print(filename)
    du -sh @(filename)
```

--------------------------------

### Enable Jupytext Server Extension

Source: https://github.com/mwouts/jupytext/blob/main/docs/install.md

Manually enable the Jupytext server extension if it's not automatically activated upon starting Jupyter.

```bash
jupyter serverextension enable jupytext
```

--------------------------------

### CLI Reference: Paired Notebooks

Source: https://context7.com/mwouts/jupytext/llms.txt

Set up paired notebooks and keep them synchronized using `--set-formats` and `--sync`.

```APIDOC
### Paired notebooks — `--set-formats` and `--sync`

Set up paired notebooks and keep them synchronized.

```bash
# Pair a notebook with a percent script
jupytext --set-formats ipynb,py:percent notebook.ipynb
# → creates notebook.py, both files share the same content

# Pair with MyST Markdown
jupytext --set-formats ipynb,md:myst notebook.ipynb

# Pair with multiple formats
jupytext --set-formats ipynb,py:percent,md:myst notebook.ipynb

# Sync all paired files (uses the most recently modified file as source)
jupytext --sync notebook.ipynb
jupytext --sync notebook.py   # equivalent

# Check sync status / list paired paths
jupytext --paired-paths notebook.ipynb

# Verify the source file is the newest before syncing
jupytext --check-source-is-newer --sync notebook.py
```
```

--------------------------------

### C++ Output to Notebook

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_cpp/xcpp_by_quantstack.ipynb

Demonstrates how to print output to the notebook frontend using std::cout.

```cpp
#include <iostream>

std::cout << "some output" << std::endl;
```

--------------------------------

### Install Jupytext with Conda

Source: https://github.com/mwouts/jupytext/blob/main/docs/index.md

Install Jupytext using conda from the conda-forge channel. This is an alternative installation method for users who prefer conda.

```none
conda install jupytext -c conda-forge

```

--------------------------------

### Define and Execute SAS Macro

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_sas/sas.ipynb

This example defines a SAS macro named 'test' that creates a temporary dataset and prints its first 10 observations. It then calls the macro to execute it. Note that '%macro' cannot be the first line of text in the cell.

```sas
/* Note when defining macros "%macro" cannot be the first line of text in the cell */
%macro test;
    data temp;
        set sashelp.cars;
        name = "testx";
    run; 
    proc print data = temp (obs=10);
    run;
%mend test;

%test
```

--------------------------------

### Subfolder Notebook Pairing (pyproject.toml)

Source: https://github.com/mwouts/jupytext/blob/main/docs/config.md

Configure Jupytext for subfolder pairing using pyproject.toml. This mirrors the jupytext.toml setup, directing .ipynb files to 'notebooks/' and .py files to 'scripts/'.

```default
[tool.jupytext.formats]
"notebooks/" = "ipynb"
"scripts/" = "py:percent"
```

--------------------------------

### Install Jupytext Extension for Specific JupyterLab Versions

Source: https://github.com/mwouts/jupytext/blob/main/jupyterlab/packages/jupyterlab-jupytext-extension/README.md

Use these commands to install specific versions of the jupyterlab-jupytext extension if you are not using JupyterLab 4.x. Ensure jupytext is installed first.

```bash
jupyter labextension install jupyterlab-jupytext@1.3.11  # for JupyterLab 3.x
```

```bash
jupyter labextension install jupyterlab-jupytext@1.2.2  # for JupyterLab 2.x
```

```bash
jupyter labextension install jupyterlab-jupytext@1.1.1  # for JupyterLab 1.x
```

--------------------------------

### GoNB with Command-Line Flags

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_go/hello_world_gonb.ipynb

Demonstrates passing command-line flags to a Go main function using GoNB's %% syntax. Imports 'flag' and 'fmt' packages.

```go
import (
    "flag"
    "fmt"
)

var flagWho = flag.String("who", "", "Your name!")

%% --who=world
fmt.Printf("Hello %s!\n", *flagWho)
```

--------------------------------

### Multiple Format Specifications (pyproject.toml)

Source: https://github.com/mwouts/jupytext/blob/main/docs/config.md

Configure Jupytext with multiple format specifications using pyproject.toml. This example pairs tutorial notebooks to markdown and other notebooks to Python scripts.

```toml
[[tool.jupytext.formats]]
"notebooks/tutorials/" = "ipynb"
"docs/tutorials/" = "md"

[[tool.jupytext.formats]]
"notebooks/" = "ipynb"
"scripts/" = "py:percent"
```

--------------------------------

### Install Jupytext with Conda

Source: https://github.com/mwouts/jupytext/blob/main/README.md

Install Jupytext in your Python environment using conda.

```bash
conda install jupytext -c conda-forge
```

--------------------------------

### Basic Go Hello World

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_go/hello_world_gonb.ipynb

A standard Go main function that prints 'Hello World!' to the console.

```go
func main() {
    fmt.Printf("Hello World!")
}
```

--------------------------------

### Import Plotly for Interactive Plots

Source: https://github.com/mwouts/jupytext/blob/main/demo/World population.myst.md

Imports plotly.offline and plotly.graph_objs for creating interactive plots and initializes the notebook mode for offline use. Ensure plotly is installed.

```python
import plotly.offline as offline
import plotly.graph_objs as go

offline.init_notebook_mode()
```

--------------------------------

### Subfolder Notebook Pairing (jupytext.toml)

Source: https://github.com/mwouts/jupytext/blob/main/docs/config.md

Configure Jupytext to pair notebooks in specific subfolders. This example places .ipynb files in 'notebooks/' and their .py representations in 'scripts/'.

```default
[formats]
"notebooks/" = "ipynb"
"scripts/" = "py:percent"
```

--------------------------------

### Instantiate and Call Java Method

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_java/simple-helloworld.ipynb

Demonstrates how to create an instance of the 'A' class and invoke its 'hello' method. This is a common pattern for object-oriented programming in Java.

```java
new A().hello();
```

--------------------------------

### Install Jupytext in User Mode

Source: https://github.com/mwouts/jupytext/blob/main/docs/install.md

Install Jupytext in user mode for read-only Python environments, such as those used with JupyterHub.

```bash
/path_to_your_jupyter_environment/python -m pip install jupytext --user
```

--------------------------------

### Set Up and Sync Paired Notebooks (CLI)

Source: https://context7.com/mwouts/jupytext/llms.txt

Use Jupytext CLI commands to pair notebooks with text files (e.g., Python scripts, Markdown) for automatic synchronization. The `--set-formats` command establishes the pairing, while `--sync` performs the synchronization.

```bash
# Pair a notebook with a percent script
jupytext --set-formats ipynb,py:percent notebook.ipynb
# → creates notebook.py, both files share the same content

# Pair with MyST Markdown
jupytext --set-formats ipynb,md:myst notebook.ipynb

# Pair with multiple formats
jupytext --set-formats ipynb,py:percent,md:myst notebook.ipynb

# Sync all paired files (uses the most recently modified file as source)
jupytext --sync notebook.ipynb
jupytext --sync notebook.py   # equivalent

# Check sync status / list paired paths
jupytext --paired-paths notebook.ipynb

# Verify the source file is the newest before syncing
jupytext --check-source-is-newer --sync notebook.py
```

--------------------------------

### Reformat and Sync Paired Files

Source: https://context7.com/mwouts/jupytext/llms.txt

Combine reformatting with 'black' and synchronization of paired notebook files in a single step.

```bash
jupytext --sync --pipe black notebook.ipynb
```

--------------------------------

### GoNB with %args for Flags

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_go/hello_world_gonb.ipynb

Shows how to use the %args directive in GoNB to set command-line flags for the main function. Parses flags and prints a formatted string.

```go
%args --who=Wally

func main() {
    flag.Parse()
    fmt.Printf("Where is %s?", *flagWho)
}
```

--------------------------------

### Print Hello World in SageMath

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/sage_print_hello.md

Use the print() function to display text output in SageMath. This is a fundamental operation for debugging and displaying results.

```sage
print("Hello world")
```

--------------------------------

### Install Jupytext with Pip

Source: https://github.com/mwouts/jupytext/blob/main/docs/index.md

Install Jupytext in your Python environment using pip. This command should be run in the Python environment where you use Jupyter.

```none
pip install jupytext

```

--------------------------------

### Print Hello World in C#

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_cs/csharp.ipynb

A basic C# snippet to print 'Hello World!' to the console. This is often the first program written when learning a new language.

```csharp
Console.WriteLine("Hello World!");
```

--------------------------------

### Pre-commit Hook for Sync and Reformat with Black

Source: https://context7.com/mwouts/jupytext/llms.txt

Configure a .pre-commit-config.yaml to sync paired notebooks and reformat them with 'black' in one step.

```yaml
# Sync AND reformat with black in one step
repos:
- repo: https://github.com/mwouts/jupytext
  rev: v1.19.3
  hooks:
  - id: jupytext
    args: [--sync, --pipe, black]
    additional_dependencies:
      - black==24.3.0

- repo: https://github.com/psf/black
  rev: 24.3.0
  hooks:
  - id: black
    language_version: python3

```

--------------------------------

### Convert Notebooks to Different Formats

Source: https://github.com/mwouts/jupytext/blob/main/docs/using-cli.md

Use the `--to` flag to convert a notebook to a specified format. You can also specify sub-formats like `py:percent` for the double percent format. Use `--opt` to pass options to the formatters, such as disabling magic command commenting.

```bash
jupytext --to py notebook.ipynb                 # convert notebook.ipynb to a .py file
```

```bash
jupytext --to py:percent notebook.ipynb         # convert notebook.ipynb to a .py file in the double percent format
```

```bash
jupytext --to py:percent --opt comment_magics=false notebook.ipynb   # same as above + do not comment magic commands
```

```bash
jupytext --to markdown notebook.ipynb           # convert notebook.ipynb to a .md file
```

```bash
jupytext --output script.py notebook.ipynb      # convert notebook.ipynb to a script.py file
```

--------------------------------

### Show Differences Between Two Notebooks

Source: https://context7.com/mwouts/jupytext/llms.txt

Compare two notebook files and display the differences between them.

```bash
jupytext --diff notebook_v1.ipynb notebook_v2.ipynb
```

--------------------------------

### C++ Documentation Lookup

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_cpp/xcpp_by_quantstack.ipynb

Demonstrates how to use the '?' operator for quick help and documentation lookup on standard library types like std::vector.

```cpp
?std::vector
```

--------------------------------

### Publish Jupytext Extension: Package and Test

Source: https://github.com/mwouts/jupytext/blob/main/jupyterlab/packages/jupyterlab-jupytext-extension/README.md

Steps to package the jupyterlab-jupytext extension locally and test the installation using a generated tarball. Ensure Node.js is installed and the version in package.json is bumped.

```bash
cd jupyterlab/packages/jupyterlab-jupytext-extension

# Package the extension
npm pack

# Test the extension locally
jupyter labextension install jupyterlab-jupytext-xxx.tgz
```

--------------------------------

### Instantiate and Use Javascript Class

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_js/ijavascript.ipynb

Creates a new instance of the `User` class named `John` and calls its `sayHello` method, displaying the greeting.

```javascript
let John = new User("John");
John.sayHello();
```

--------------------------------

### Empty Code Cell

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/convert_to_py_then_test_with_update83.md

An example of an empty code cell in a Jupyter notebook.

```python

```

--------------------------------

### Execute Notebooks During Conversion

Source: https://github.com/mwouts/jupytext/blob/main/docs/using-cli.md

Convert a notebook from a text format to an `.ipynb` file and execute its cells simultaneously. This is useful for running notebooks as part of a workflow.

```bash
jupytext --to notebook --execute notebook.md    # convert notebook.md to an .ipynb file and run it
```

```bash
jupytext --set-formats ipynb,md --execute *.md
```

--------------------------------

### Load Data in Stata

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_stata/stata_notebook.ipynb

Loads the 'auto' dataset from Stata Press. Ensure the stata_kernel is installed and configured.

```stata
use http://www.stata-press.com/data/r13/auto
```

--------------------------------

### Shuffle Vector with %timeit

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/xcpp_by_quantstack.md

Demonstrates the use of the %timeit magic command to measure the execution time of shuffling a vector. Requires including algorithm and vector headers.

```c++
#include <algorithm>
#include <vector>
```

```c++
std::vector<double> to_shuffle = {1, 2, 3, 4};
```

```c++
%timeit std::random_shuffle(to_shuffle.begin(), to_shuffle.end());
```

--------------------------------

### Upgrade Playwright and Browsers

Source: https://github.com/mwouts/jupytext/blob/main/jupyterlab/packages/jupyterlab-jupytext-extension/ui-tests/README.md

Commands to update the Playwright package to the latest version and install the corresponding browser binaries.

```sh
cd ./ui-tests
jlpm up "@playwright/test"
jlpm playwright install
```

--------------------------------

### Shell Command Example

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/md/plain_markdown.md

A generic code snippet, likely a shell command, without an explicit language identifier.

```shell
echo 'Hello world'
```

--------------------------------

### Python Code Cell Example

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/md/plain_markdown.md

A standard Python code cell, indicated by triple backticks and the language specifier.

```python
"""This code cell starts with ` ```python`"""
1 + 1
```

--------------------------------

### Mapping and List Creation with Piping

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_coconut/coconut_homepage_demo.ipynb

Illustrates mapping a function (squaring) over a range and collecting the results into a list using the pipe operator and partial application.

```coconut
range(10) |> map$(pow$(?, 2)) |> list
```

--------------------------------

### Enter Development Shell with Pixi

Source: https://github.com/mwouts/jupytext/blob/main/docs/developing.md

Activates a development shell environment managed by Pixi, setting up the necessary tools and dependencies for local development.

```bash
pixi shell
```

--------------------------------

### Use 'collect' with Range Step

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_myst/Reference Guide for Calysto Scheme.md

Uses the 'collect' macro with a custom range step (start, stop, step).

```scheme
(collect (* n n) for n in (range 5 20 3))
```

--------------------------------

### Xarray Initialization and View

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_cpp/xcpp_by_quantstack.ipynb

Demonstrates initializing xt::xarray with nested braces and using xt::view to access a specific row. Requires xtensor headers.

```cpp
#include <iostream>

#include "xtensor/xarray.hpp"
#include "xtensor/xio.hpp"
#include "xtensor/xview.hpp"

xt::xarray<double> arr1
  {{1.0, 2.0, 3.0},
   {2.0, 5.0, 7.0},
   {2.0, 5.0, 7.0}};

xt::xarray<double> arr2
  {5.0, 6.0, 7.0};

xt::view(arr1, 1) + arr2
```

--------------------------------

### Launch Calysto Scheme in IPython

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/Reference Guide for Calysto Scheme.md

Launch Calysto Scheme in various IPython environments including the console, qtconsole, or notebook.

```bash
ipython console --kernel calysto_scheme
```

```bash
ipython qtconsole --kernel calysto_scheme
```

```bash
ipython notebook --kernel calysto_scheme
```

--------------------------------

### Call Object Method in Javascript

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_js/ijavascript.ipynb

Invokes the `start` method of the `myCar` object and logs the returned string to the console.

```javascript
console.log("start:", myCar.start());
```

--------------------------------

### Execute and Pair Multiple Markdown Files

Source: https://context7.com/mwouts/jupytext/llms.txt

Execute multiple markdown files and pair them with their notebook counterparts.

```bash
jupytext --set-formats ipynb,md --execute *.md
```

--------------------------------

### CLI Reference: Format Conversion

Source: https://context7.com/mwouts/jupytext/llms.txt

Convert notebooks between various supported formats using the `--to` and `--from` command-line options.

```APIDOC
## CLI Reference

### Format conversion

Convert notebooks between any supported formats using `--to` and optionally `--from`.

```bash
# .ipynb → py:percent (default script format since v1.17)
jupytext --to py notebook.ipynb

# .ipynb → explicit percent format
jupytext --to py:percent notebook.ipynb

# .ipynb → MyST Markdown
jupytext --to md:myst notebook.ipynb

# .ipynb → R Markdown
jupytext --to Rmd notebook.ipynb

# .ipynb → Quarto Markdown (.qmd)
jupytext --to qmd notebook.ipynb

# .ipynb → Marimo script
jupytext --to py:marimo notebook.ipynb

# Python script → .ipynb (no outputs)
jupytext --to notebook notebook.py

# Python script → .ipynb, preserving existing outputs
jupytext --update --to notebook notebook.py

# Custom output path
jupytext --to py:percent --output scripts/analysis.py notebooks/analysis.ipynb

# Print result to stdout
jupytext --to md --output - notebook.ipynb

# Read from stdin, write to stdout
echo "# %%" | jupytext --from py:percent --to notebook --output result.ipynb
```
```

--------------------------------

### Initialize Plotly API in Julia

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_julia/julia_benchmark_plotly_barchart.ipynb

Sets up the Plotly API credentials for making plots. Ensure you replace placeholder values with your actual username and API key obtained from the Plotly website.

```julia
# IJulia rocks! So does Plotly. Check it out

using Plotly
api_key = "" # visit https://plot.ly/api to generate an API username and password
username = ""

Plotly.signin(username, api_key)
```

--------------------------------

### Parse YAML String with Python

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_py/jupyter_again.ipynb

Loads a YAML string and dumps it back using the PyYAML library. Ensure PyYAML is installed.

```python
c = '''
title: "Quick test"
output:
  ioslides_presentation:
    widescreen: true
    smaller: true
editor_options:
     chunk_output_type console
'''
```

```python
import yaml
print(yaml.dump(yaml.load(c)))
```

--------------------------------

### TCL Variable Assignment and Output

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_tcl/tcl_test.ipynb

Demonstrates how to set a variable and print its value to the console in TCL.

```tcl
set a 1
puts "a = $a"
```

--------------------------------

### Update Notebook Metadata with JSON

Source: https://context7.com/mwouts/jupytext/llms.txt

Update the raw notebook metadata with specific JSON content, for example, to set Jupytext formats.

```bash
jupytext --update-metadata '{"jupytext": {"formats": "ipynb,py:percent"}}' notebook.ipynb
```

--------------------------------

### Get First N Elements of Lazy List 'fibs'

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_myst/Reference Guide for Calysto Scheme.md

Retrieves the first 30 Fibonacci numbers from the 'fibs' lazy list.

```scheme
(first 30 fibs)
```

--------------------------------

### Import pandas Library

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_py/nteract_with_parameter.ipynb

Import the pandas library, commonly used for data manipulation and analysis in Python. Ensure pandas is installed in your environment.

```python
import pandas as pd
```

--------------------------------

### Display Audio in Jupyter

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_cpp/xcpp_by_quantstack.ipynb

Instantiate an audio object and display it. The audio will be rendered as an HTML audio player in the notebook.

```cpp
au::audio drums("audio/audio.wav");
drums
```

--------------------------------

### R Plotting Example

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/Rmd_to_ipynb/knitr-spin.ipynb

Generate plots using R's base plotting functions. Adjust margins for better visualization if needed.

```R
par(mar = c(4, 4, .1, .1)); plot(x)
```

--------------------------------

### Robot Framework Task Execution

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_robot/simple_robot_notebook.ipynb

Defines a task that creates a list, uses the 'Head' keyword to get the first element, and asserts its value.

```robotframework
*** Tasks ***

Get head
    ${array}=  Create list  1  2  3  4  5
    ${head}=  Head  ${array}
    Should be equal  ${head}  1
```

--------------------------------

### Using Reduce for Product Calculation

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_coconut/coconut_homepage_demo.ipynb

Demonstrates the use of `reduce` with a multiplication operator to calculate the product of elements. This is a common functional programming pattern.

```coconut
product = reduce$(*)
```

--------------------------------

### Test ipynb -> (py:percent + ipynb) -> ipynb Paired Conversion

Source: https://github.com/mwouts/jupytext/blob/main/docs/using-cli.md

This command tests the round-trip conversion for paired notebooks, where a notebook is converted to `py:percent` and an `.ipynb` file simultaneously, and then back to `.ipynb`. The `--update` flag ensures that the paired notebook is updated if changes are detected.

```bash
jupytext --test --update notebook.ipynb --to py:percent
```

--------------------------------

### Load R Tidyverse Package

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_py/Notebook_with_R_magic.ipynb

Load the 'tidyverse' package in R using the %%R magic command. Ensure R and the package are installed in your environment.

```r
suppressMessages(require(tidyverse))
```

--------------------------------

### List Files in Directory

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_bash/sample_bash_notebook.ipynb

Use `ls` to display the contents of the current directory. This command is useful for navigating and understanding the file structure.

```bash
ls
```

--------------------------------

### Define Custom Image Representation for Display

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/xcpp_by_quantstack.md

Provides an example of implementing `mime_bundle_repr` to enable rich display of custom types (like images) in Jupyter.

```C++
#include <string>
#include <fstream>

#include "xtl/xbase64.hpp"
#include "xeus/xjson.hpp"

namespace im
{
    struct image
    {
        inline image(const std::string& filename)
        {
            std::ifstream fin(filename, std::ios::binary);   
            m_buffer << fin.rdbuf();
        }
        
        std::stringstream m_buffer;
    };
    
    xeus::xjson mime_bundle_repr(const image& i)
    {
        auto bundle = xeus::xjson::object();
        bundle["image/png"] = xtl::base64encode(i.m_buffer.str());
        return bundle;
    }
}

```

--------------------------------

### Import Calysto Display Module

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_scheme/Reference Guide for Calysto Scheme.ipynb

Imports the 'calysto.display' module to enable display functionalities, such as rendering HTML content.

```scheme
(import "calysto.display")
```

--------------------------------

### Display of compilation errors

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/evcxr_jupyter_tour.md

Shows how compilation errors are presented in the EvCxR kernel. This example demonstrates a common error of passing a `String` instead of an `&str`.

```rust
let mut s = String::new();
s.push_str(format!("foo {}", 42));
```

--------------------------------

### Execute Expression with 'time' Macro

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_myst/Reference Guide for Calysto Scheme.md

Demonstrates how to use the 'time' macro to measure the execution of a simple expression.

```scheme
(time (car '(1 2 3 4)))
```

--------------------------------

### Use a Haskell function

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_haskell/haskell_notebook.ipynb

Demonstrates how to call the previously defined `f` function with specific arguments. The output shows the result of the function call.

```haskell
f 1 2 
```

--------------------------------

### Display Markdown Output on Screen

Source: https://github.com/mwouts/jupytext/blob/main/docs/using-cli.md

Convert a notebook to Markdown format and display the output directly on the standard output stream instead of writing to a file.

```bash
jupytext --to md --output - notebook.ipynb      # display the markdown version on screen
```

--------------------------------

### Create a Javascript Object Literal

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_js/ijavascript.ipynb

Initializes a JavaScript object `myCar` with properties such as color, weight, model, and an array of doors, along with a method `start`.

```javascript
const myCar = {
    color: "blue",
    weight: 850,
    model: "fiat",
    start: () => "car started!",
    doors: [1,2,3,4]
}
```

--------------------------------

### Create a Bar Plot with XPlot in C#

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_cs/csharp.ipynb

Demonstrates how to create a bar plot using the XPlot.Plotly library in C#. Ensure XPlot is installed and referenced in your project.

```csharp
using XPlot.Plotly;

var bar = new Graph.Bar
{
    name = "Bar",
    x = new[] {'A', 'B', 'C'},
    y = new[] {1, 3, 2}
};

var chart = Chart.Plot(new[] {bar});
chart.WithTitle("A bar plot");
display(chart);
```

--------------------------------

### Access Help Information in EVCXR

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_md/evcxr_jupyter_tour.md

The ':help' command provides access to information about other built-in commands available in EVCXR. Consult this for a list of available functionalities.

```rust
:help
```

--------------------------------

### Build Jupytext Documentation

Source: https://github.com/mwouts/jupytext/blob/main/docs/developing.md

Builds the HTML documentation for Jupytext locally using Sphinx. First, it removes the old build directory, then runs the Sphinx build command.

```bash
rm -rf docs/_build
```

```bash
pixi run -e docs sphinx-build docs docs/_build
```

--------------------------------

### Render ioslides Presentation from Rmd

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/Rmd_to_ipynb/ioslides.ipynb

Command-line instruction to render an Rmd file into an ioslides HTML presentation.

```bash
R -e 'rmarkdown::render("ioslides.Rmd")'
```

--------------------------------

### Execute SQL Query in SAS

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/outputs/ipynb_to_myst/sas.md

Use PROC SQL to select data from a SAS dataset. This example retrieves the first 10 observations from the 'sashelp.cars' dataset.

```sas
proc sql;
    select *
    from sashelp.cars (obs=10)
    ;
quit;
```

--------------------------------

### TCL For Loop

Source: https://github.com/mwouts/jupytext/blob/main/tests/data/notebooks/inputs/ipynb_tcl/tcl_test.ipynb

Illustrates the basic syntax of a for loop in TCL, iterating a specified number of times and printing a value in each iteration.

```tcl
for {set i 0} {$i < 10} {incr i} {
    puts "I inside first loop: $i"
}
```

--------------------------------

### Pre-commit Configuration for isort, ruff, and black

Source: https://github.com/mwouts/jupytext/blob/main/docs/using-pre-commit.md

This configuration is for projects that do not use Jupytext's pre-commit hook but commit only the .py or .md representation of notebooks. It sets up isort, ruff, and black for code formatting and linting.

```yaml
repos:
- repo: https://github.com/pycqa/isort
    rev: 5.11.2
    hooks:
    - id: isort
      args: [--treat-comment-as-code, "# %%", --float-to-top]

- repo: https://github.com/astral-sh/ruff-pre-commit
  rev: v0.0.275
  hooks:
    - id: ruff
      args: [--fix, --exit-non-zero-on-fix]

- repo: https://github.com/psf/black
    rev: 23.3.0
    hooks:
    - id: black
      language_version: python3

```

--------------------------------

### Install Jupyter Kernel for Development

Source: https://github.com/mwouts/jupytext/blob/main/docs/developing.md

Registers a Jupyter kernel named 'jupytext-dev' that points to the current Python development environment, enabling notebooks to use local Jupytext code.

```bash
python -m ipykernel install --name jupytext-dev --user
```

--------------------------------

### Basic Python Plotting Example

Source: https://github.com/mwouts/jupytext/blob/main/demo/get_started.md

A simple Python code snippet using numpy and matplotlib to generate a scatter plot. This can be used to experiment with Jupytext's code conversion.

```python
import numpy as np
import matplotlib.pyplot as plt

plt.scatter(*np.random.randn(2, 100), c=np.random.randn(100), s=np.random.rand(100)*100)
```