Add files using upload-large-folder tool

testbed/matplotlib__matplotlib/.appveyor.yml

@@ -0,0 +1,107 @@
+# With infos from
+# http://tjelvarolsson.com/blog/how-to-continuously-test-your-python-code-on-windows-using-appveyor/
+# https://packaging.python.org/en/latest/appveyor/
+# https://github.com/rmcgibbo/python-appveyor-conda-example
+
+# Backslashes in quotes need to be escaped: \ -> "\\"
+branches:
+  except:
+    - /auto-backport-.*/
+    - /^v\d+\.\d+\.[\dx]+-doc$/
+
+skip_commits:
+  message: /\[ci doc\]/
+  files:
+    - doc/
+    - galleries/
+
+clone_depth: 50
+
+image: Visual Studio 2017
+
+environment:
+
+  global:
+    PYTHONFAULTHANDLER: 1
+    PYTHONIOENCODING: UTF-8
+    PYTEST_ARGS: -raR --numprocesses=auto --timeout=300 --durations=25
+                 --cov-report= --cov=lib --log-level=DEBUG
+
+  matrix:
+    - PYTHON_VERSION: "3.9"
+      CONDA_INSTALL_LOCN: "C:\\Miniconda3-x64"
+      TEST_ALL: "no"
+    - PYTHON_VERSION: "3.10"
+      CONDA_INSTALL_LOCN: "C:\\Miniconda3-x64"
+      TEST_ALL: "no"
+
+# We always use a 64-bit machine, but can build x86 distributions
+# with the PYTHON_ARCH variable
+platform:
+    - x64
+
+# all our python builds have to happen in tests_script...
+build: false
+
+cache:
+  - '%LOCALAPPDATA%\pip\Cache'
+  - '%USERPROFILE%\.cache\matplotlib'
+
+init:
+  - echo %PYTHON_VERSION% %CONDA_INSTALL_LOCN%
+
+install:
+  - set PATH=%CONDA_INSTALL_LOCN%;%CONDA_INSTALL_LOCN%\scripts;%PATH%;
+  - conda config --set always_yes true
+  - conda config --set show_channel_urls yes
+  - conda config --prepend channels conda-forge
+
+  # For building, use a new environment
+  # Add python version to environment
+  # `^ ` escapes spaces for indentation
+  - echo ^ ^ - python=%PYTHON_VERSION% >> environment.yml
+  - conda env create -f environment.yml
+  - activate mpl-dev
+  - conda install -c conda-forge pywin32
+  - echo %PYTHON_VERSION% %TARGET_ARCH%
+  # Show the installed packages + versions
+  - conda list
+
+test_script:
+  # Now build the thing..
+  - set LINK=/LIBPATH:%cd%\lib
+  - pip install -ve .
+  # this should show no freetype dll...
+  - set "DUMPBIN=%VS140COMNTOOLS%\..\..\VC\bin\dumpbin.exe"
+  - '"%DUMPBIN%" /DEPENDENTS lib\matplotlib\ft2font*.pyd | findstr freetype.*.dll && exit /b 1 || exit /b 0'
+
+  # this are optional dependencies so that we don't skip so many tests...
+  - if x%TEST_ALL% == xyes conda install -q ffmpeg inkscape miktex
+  # missing packages on conda-forge for imagemagick
+  # This install sometimes failed randomly :-(
+  #- choco install imagemagick
+
+  # Test import of tkagg backend
+  - python -c "import matplotlib as m; m.use('tkagg'); import matplotlib.pyplot as plt; print(plt.get_backend())"
+  # tests
+  - echo The following args are passed to pytest %PYTEST_ARGS%
+  - pytest %PYTEST_ARGS%
+
+artifacts:
+  - path: result_images\*
+    name: result_images
+    type: zip
+
+on_finish:
+  - conda install codecov
+  - codecov -e PYTHON_VERSION PLATFORM
+
+on_failure:
+  # Generate a html for visual tests
+  - python tools/visualize_tests.py --no-browser
+  - echo zipping images after a failure...
+  - 7z a result_images.zip result_images\ | grep -v "Compressing"
+  - appveyor PushArtifact result_images.zip
+
+matrix:
+  fast_finish: true

testbed/matplotlib__matplotlib/.coveragerc

@@ -0,0 +1,16 @@
+[run]
+branch = true
+source =
+    matplotlib
+    mpl_toolkits
+omit = matplotlib/_version.py
+
+[report]
+exclude_lines =
+    pragma: no cover
+    raise NotImplemented
+    def __str__
+    def __repr__
+    if __name__ == .__main__.:
+    if TYPE_CHECKING:
+    if typing.TYPE_CHECKING:

testbed/matplotlib__matplotlib/.devcontainer/devcontainer.json

@@ -0,0 +1,38 @@
+{
+  "hostRequirements": {
+    "memory": "8gb",
+    "cpus": 4
+  },
+  "image": "mcr.microsoft.com/devcontainers/universal:2",
+  "features": {
+    "ghcr.io/devcontainers/features/desktop-lite:1": {},
+    "ghcr.io/rocker-org/devcontainer-features/apt-packages:1": {
+      "packages": "inkscape,ffmpeg,dvipng,lmodern,cm-super,texlive-latex-base,texlive-latex-extra,texlive-fonts-recommended,texlive-latex-recommended,texlive-pictures,texlive-xetex,fonts-wqy-zenhei,graphviz,fonts-crosextra-carlito,fonts-freefont-otf,fonts-humor-sans,fonts-noto-cjk,optipng"
+    }
+  },
+  "onCreateCommand": ".devcontainer/setup.sh",
+  "postCreateCommand": "",
+  "forwardPorts": [6080],
+  "portsAttributes": {
+    "6080": {
+      "label": "desktop"
+    }
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-python.python",
+        "yy0931.mplstyle",
+        "eamodio.gitlens",
+        "ms-vscode.live-server"
+      ],
+      "settings": {}
+    },
+    "codespaces": {
+      "openFiles": [
+        "README.md",
+        "doc/devel/codespaces.md"
+      ]
+    }
+  }
+}

testbed/matplotlib__matplotlib/.devcontainer/setup.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -e
+
+"${SHELL}" <(curl -Ls micro.mamba.pm/install.sh) < /dev/null
+
+conda init --all
+micromamba shell init -s bash
+micromamba env create -f environment.yml --yes
+# Note that `micromamba activate mpl-dev` doesn't work, it must be run by the
+# user (same applies to `conda activate`)
+echo "envs_dirs:
+  - /home/codespace/micromamba/envs" > /opt/conda/.condarc

testbed/matplotlib__matplotlib/.flake8

@@ -0,0 +1,97 @@
+[flake8]
+max-line-length = 88
+select =
+    # flake8 default
+    D, E, F, W,
+ignore =
+    # flake8 default
+    E121,E123,E126,E226,E24,E704,W503,W504,
+    # Additional ignores:
+    E127, E131,
+    E266,
+    E305, E306,
+    E741,
+    F841,
+    # pydocstyle
+    D100, D101, D102, D103, D104, D105, D106,
+    D200, D202, D204, D205,
+    D301,
+    D400, D401, D403, D404
+    # ignored by pydocstyle numpy docstring convention
+    D107, D203, D212, D213, D402, D413, D415, D416, D417,
+
+exclude =
+    .git
+    build
+    doc/gallery
+    doc/tutorials
+    # External files.
+    tools/gh_api.py
+    .tox
+    .eggs
+
+per-file-ignores =
+    setup.py: E402
+
+    lib/matplotlib/__init__.py: E402, F401
+    lib/matplotlib/_animation_data.py: E501
+    lib/matplotlib/_api/__init__.py: F401
+    lib/matplotlib/_cm.py: E122, E202, E203, E302
+    lib/matplotlib/_mathtext.py: E221, E251
+    lib/matplotlib/_mathtext_data.py: E122, E203, E261
+    lib/matplotlib/axes/__init__.py: F401, F403
+    lib/matplotlib/backends/backend_template.py: F401
+    lib/matplotlib/font_manager.py: E501
+    lib/matplotlib/image.py: F401, F403
+    lib/matplotlib/mathtext.py: E221
+    lib/matplotlib/pylab.py: F401, F403
+    lib/matplotlib/pyplot.py: F401, F811
+    lib/matplotlib/tests/test_mathtext.py: E501
+    lib/matplotlib/transforms.py: E201, E202, E203
+    lib/matplotlib/tri/_triinterpolate.py: E201, E221
+    lib/mpl_toolkits/axes_grid1/axes_size.py: E272
+    lib/mpl_toolkits/axisartist/__init__.py: F401
+    lib/mpl_toolkits/axisartist/angle_helper.py: E221
+    lib/pylab.py: F401, F403
+
+    doc/conf.py: E402
+    galleries/users_explain/artists/paths.py: E402
+    galleries/users_explain/artists/patheffects_guide.py: E402
+    galleries/users_explain/artists/transforms_tutorial.py: E402, E501
+    galleries/users_explain/colors/colormaps.py: E501
+    galleries/users_explain/colors/colors.py: E402
+    galleries/tutorials/artists.py: E402
+    galleries/users_explain/axes/constrainedlayout_guide.py: E402
+    galleries/users_explain/axes/legend_guide.py: E402
+    galleries/users_explain/axes/tight_layout_guide.py: E402
+    galleries/users_explain/animations/animations.py: E501
+    galleries/tutorials/images.py: E501
+    galleries/tutorials/pyplot.py: E402, E501
+    galleries/users_explain/text/annotations.py: E402, E501
+    galleries/users_explain/text/mathtext.py: E501
+    galleries/users_explain/text/text_intro.py: E402
+    galleries/users_explain/text/text_props.py: E501
+
+    galleries/examples/animation/frame_grabbing_sgskip.py: E402
+    galleries/examples/images_contours_and_fields/tricontour_demo.py: E201
+    galleries/examples/images_contours_and_fields/tripcolor_demo.py: E201
+    galleries/examples/images_contours_and_fields/triplot_demo.py: E201
+    galleries/examples/lines_bars_and_markers/marker_reference.py: E402
+    galleries/examples/misc/print_stdout_sgskip.py: E402
+    galleries/examples/misc/table_demo.py: E201
+    galleries/examples/style_sheets/bmh.py: E501
+    galleries/examples/subplots_axes_and_figures/demo_constrained_layout.py: E402
+    galleries/examples/text_labels_and_annotations/custom_legends.py: E402
+    galleries/examples/ticks/date_concise_formatter.py: E402
+    galleries/examples/ticks/date_formatters_locators.py: F401
+    galleries/examples/user_interfaces/embedding_in_gtk3_panzoom_sgskip.py: E402
+    galleries/examples/user_interfaces/embedding_in_gtk3_sgskip.py: E402
+    galleries/examples/user_interfaces/embedding_in_gtk4_panzoom_sgskip.py: E402
+    galleries/examples/user_interfaces/embedding_in_gtk4_sgskip.py: E402
+    galleries/examples/user_interfaces/gtk3_spreadsheet_sgskip.py: E402
+    galleries/examples/user_interfaces/gtk4_spreadsheet_sgskip.py: E402
+    galleries/examples/user_interfaces/mpl_with_glade3_sgskip.py: E402
+    galleries/examples/user_interfaces/pylab_with_gtk3_sgskip.py: E402
+    galleries/examples/user_interfaces/pylab_with_gtk4_sgskip.py: E402
+    galleries/examples/userdemo/pgf_preamble_sgskip.py: E402
+force-check = True

testbed/matplotlib__matplotlib/.git-blame-ignore-revs

@@ -0,0 +1,14 @@
+# style: end-of-file-fixer pre-commit hook
+c1a33a481b9c2df605bcb9bef9c19fe65c3dac21
+
+# style: trailing-whitespace pre-commit hook
+213061c0804530d04bbbd5c259f10dc8504e5b2b
+
+# style: check-docstring-first pre-commit hook
+046533797725293dfc2a6edb9f536b25f08aa636
+
+# chore: fix spelling errors
+686c9e5a413e31c46bb049407d5eca285bcab76d
+
+# chore: pyupgrade --py39-plus
+4d306402bb66d6d4c694d8e3e14b91054417070e

testbed/matplotlib__matplotlib/.git_archival.txt

@@ -0,0 +1,4 @@
+node: $Format:%H$
+node-date: $Format:%cI$
+describe-name: $Format:%(describe:tags=true)$
+ref-names: $Format:%D$

testbed/matplotlib__matplotlib/.gitattributes

@@ -0,0 +1,6 @@
+* text=auto
+*.m diff=objc
+*.ppm binary
+*.svg binary
+*.svg linguist-language=true
+.git_archival.txt export-subst

testbed/matplotlib__matplotlib/.gitignore

@@ -0,0 +1,112 @@
+#########################################
+# OS-specific temporary and backup files
+.DS_Store
+
+#########################################
+# Editor temporary/working/backup files #
+.#*
+[#]*#
+*~
+*$
+*.bak
+*.kdev4
+.project
+.pydevproject
+*.swp
+.idea
+.vscode/
+
+# Compiled source #
+###################
+*.a
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.py[ocd]
+*.so
+
+# Python files #
+################
+# setup.py working directory
+build
+
+# setup.py dist directory
+dist
+# Egg metadata
+*.egg-info
+.eggs
+# wheel metadata
+pip-wheel-metadata/*
+# tox testing tool
+.tox
+mplsetup.cfg
+# generated by setuptools_scm
+lib/matplotlib/_version.py
+
+# OS generated files #
+######################
+.directory
+.gdb_history
+.DS_Store?
+ehthumbs.db
+Icon?
+Thumbs.db
+
+# Things specific to this project #
+###################################
+galleries/tutorials/intermediate/CL01.png
+galleries/tutorials/intermediate/CL02.png
+
+# Documentation generated files #
+#################################
+# sphinx build directory
+doc/_build
+doc/api/_as_gen
+# autogenerated by sphinx-gallery
+doc/examples
+doc/gallery
+doc/modules
+doc/plot_types
+doc/pyplots/tex_demo.png
+doc/tutorials
+doc/users/explain
+lib/dateutil
+galleries/examples/*/*.bmp
+galleries/examples/*/*.eps
+galleries/examples/*/*.pdf
+galleries/examples/*/*.png
+galleries/examples/*/*.svg
+galleries/examples/*/*.svgz
+result_images
+doc/_static/constrained_layout*.png
+doc/.mpl_skip_subdirs.yaml
+
+# Nose/Pytest generated files #
+###############################
+.pytest_cache/
+.cache/
+.coverage
+.coverage.*
+*.py,cover
+cover/
+.noseids
+
+# Conda files #
+###############
+__conda_version__.txt
+lib/png.lib
+lib/z.lib
+
+# Jupyter files #
+#################
+
+.ipynb_checkpoints/
+
+# Vendored dependencies #
+#########################
+lib/matplotlib/backends/web_backend/node_modules/
+lib/matplotlib/backends/web_backend/package-lock.json
+
+LICENSE/LICENSE_QHULL

testbed/matplotlib__matplotlib/.mailmap

@@ -0,0 +1,284 @@
+Adam Ortiz <adam.ortiz@utoronto.ca>
+
+Adrien F. Vincent <vincent.adrien@gmail.com>
+Adrien F. Vincent <vincent.adrien@gmail.com> <adrien.vincent@u-psud.fr>
+
+Aleksey Bilogur <aleksey.bilogur@gmail.com>
+
+Alexander Rudy <alex.rudy@gmail.com>
+
+Alon Hershenhorn <hershen@gmail.com>
+
+Alvaro Sanchez <sanchezgnzlz.alvaro@gmail.com>
+
+Andrew Dawson <ajdawson@acm.org> <dawson@atm.ox.ac.uk>
+
+anykraus <kraus@mpip-mainz.mpg.de> <anykraus@users.noreply.github.com>
+
+Ariel Hernán Curiale <curiale@gmail.com>
+
+Ben Cohen <bj.cohen19@gmail.com> <ben@cohen-family.org>
+
+Ben Root <ben.v.root@gmail.com> Benjamin Root <ben.v.root@gmail.com>
+
+Benedikt Daurer <benedikt.daurer@icm.uu.se>
+
+Benjamin Congdon <bencongdon96@gmail.com>
+Benjamin Congdon <bencongdon96@gmail.com> bcongdon <bcongdo2@illinois.edu>
+
+Bruno Zohreh <z.shams@bath.ac.uk>
+
+Carsten Schelp <carstenschelp@mp.nl>
+
+Casper van der Wel <caspervdw@gmail.com>
+
+Chris Holdgraf <choldgraf@gmail.com>
+
+Cho Yin Yong <choyiny@users.noreply.github.com>
+
+Chris <chrissshe@gmail.com>
+
+Christoph Gohlke <cgohlke@uci.edu> cgohlke <cgohlke@uci.edu>
+Christoph Gohlke <cgohlke@uci.edu> C. Gohlke <cgohlke@uci.edu>
+Christoph Gohlke <cjgohlke@gmail.com>
+
+Cimarron Mittelsteadt <cimarronm@gmail.com> Cimarron <cimarronm@gmail.com>
+
+cldssty <huey910@gmail.com>
+
+Conner R. Phillips <conner.r.phillips@gmail.com> <conner.r.phillips.com>
+
+Dan Hickstein <danhickstein@gmail.com>
+
+Daniel Hyams <dhyams@gmail.com>
+Daniel Hyams <dhyams@gmail.com> Daniel Hyams <dhyams@gitdev.(none)>
+
+David Kua <david@kua.io> <david.kua@mail.utoronto.ca>
+
+Devashish Deshpande <ashu.9412@gmail.com>
+
+Dietmar Schwertberger <github@schwertberger.de>
+
+Dora Fraeman Caswell <dorafraeman@gmail.com>
+
+endolith <endolith@gmail.com>
+
+Eric Dill <thedizzle@gmail.com> <edill@bnl.gov>
+
+Erik Bray <erik.m.bray@gmail.com> <embray@stsci.edu>
+
+Eric Ma <ericmajinglong@gmail.com> <ericmjl@Erics-MacBook-Pro.local>
+Eric Ma <ericmajinglong@gmail.com> <ericmjl@users.noreply.github.com>
+
+esvhd <weiliang.zhang@gmail.com>
+
+Filipe Fernandes <ocefpaf@gmail.com>
+
+Florian Le Bourdais <florian.s.lebourdais@gmail.com>
+
+Francesco Montesano <franz.bergesund@gmail.com> montefra <franz.bergesund@gmail.com>
+
+Gauravjeet <gauravjeet.kala@mail.utoronto.ca>
+
+Hajoon Choi <hajoon.choi@mail.utoronto.ca>
+
+hannah <story645@gmail.com>
+
+Hans Moritz Günther <moritz.guenther@gmx.de>
+
+Harshal Prakash Patankar <pharshalp@gmail.com>
+
+Harshit Patni <patniharshit@gmail.com>
+
+ImportanceOfBeingErnest <elch.rz@ruetz-online.de>
+
+J. Goutin <JGoutin@users.noreply.github.com> JGoutin <ginnungagap@free.fr>
+
+Jack Kelly <jack.kelly@imperial.ac.uk> <daniel.kelly10@imperial.ac.uk>
+Jack Kelly <jack.kelly@imperial.ac.uk> <jack-list@xlk.org.uk>
+
+Jaime Fernandez <jaime.frio@gmail.com>
+
+Jake Vanderplas <jakevdp@gmail.com>
+Jake Vanderplas <jakevdp@gmail.com> <jakevdp@yahoo.com>
+Jake Vanderplas <jakevdp@gmail.com> <vanderplas@astro.washington.edu>
+
+James R. Evans <jrevans1@earthlink.net>
+
+Jeff Lutgen <jlutgen@gmail.com> <jlutgen@users.noreply.github.com>
+
+Jeffrey Bingham <bingjeff@gmail.com>
+
+Jens Hedegaard Nielsen <jenshnielsen@gmail.com>
+Jens Hedegaard Nielsen <jenshnielsen@gmail.com> <jens.nielsen@ucl.ac.uk>
+
+Joel Frederico <458871+joelfrederico@users.noreply.github.com>
+
+John Hunter <jdh2358@gmail.com>
+
+Jorrit Wronski <jowr@mek.dtu.dk>
+
+Joseph Fox-Rabinovitz <jfoxrabinovitz@gmail.com> Mad Physicist <madphysicist@users.noreply.github.com>
+Joseph Fox-Rabinovitz <jfoxrabinovitz@gmail.com> Joseph Fox-Rabinovitz <joseph.r.fox-rabinovitz@nasa.gov>
+
+Jouni K. Seppänen <jks@iki.fi>
+
+Julien Lhermitte <ordirules@gmail.com>
+
+Julien Schueller <julien.schueller@gmail.com> <schueller@porsche-l64.phimeca.lan>
+Julien Schueller <julien.schueller@gmail.com> <schueller@bx-l64.phimeca.lan>
+
+Kevin Davies <kdavies4@gmail.com> <daviesk24@yahoo.com>
+
+kikocorreoso <kikocorreoso@gmail.com> <kikocorreoso@users.noreply.github.com>
+
+Klara Gerlei <klarizsofi@gmail.com>
+Klara Gerlei <klarizsofi@gmail.com> klaragerlei <s1466507@sms.ed.ac.uk>
+
+Kristen M. Thyng <kthyng@gmail.com>
+
+Kyle Sunden <sunden@wisc.edu>
+
+Leeonadoh <leo.sunpeng.li@gmail.com>
+
+Lennart Fricke <lennart@die-frickes.eu> <lennart.fricke@kabelmail.de>
+
+Levi Kilcher <levi.kilcher@nrel.gov>
+
+Leon Yin <hello.leonyin@gmail.com>
+
+Lion Krischer <lion.krischer@gmail.com> <krischer@geophysik.uni-muenchen.de>
+
+Manan Kevadiya <kevadiyamanan@gmail.com>
+Manan Kevadiya <kevadiyamanan@gmail.com> <43081866+manan2501@users.noreply.github.com>
+
+Manuel Nuno Melo <manuel.nuno.melo@gmail.com>
+
+Marco Gorelli <m.e.gorelli@gmail.com>
+Marco Gorelli <m.e.gorelli@gmail.com> <33491632+MarcoGorelli@users.noreply.github.com>
+
+Marek Rudnicki <marekrud@gmail.com>
+
+Martin Fitzpatrick <martin.fitzpatrick@gmail.com> <mfitzp@abl.es>
+
+Matt Newville <newville@cars.uchicago.edu>
+
+Matthew Emmett <memmett@gmail.com>
+Matthew Emmett <memmett@gmail.com> <memmett@unc.edu>
+
+Matthias Bussonnier <bussonniermatthias@gmail.com>
+Matthias Bussonnier <bussonniermatthias@gmail.com> <mbussonnier@ucmerced.edu>
+
+Matthias Lüthi <maluethi@protonmail.ch>
+Matthias Lüthi <maluethi@protonmail.ch> <matthias.luethi@lhep.unibe.ch>
+
+Matti Picus <matti.picus@gmail.com>
+
+Michael Droettboom <mdboom@gmail.com> <mdroe@stsci.edu>
+Michael Droettboom <mdboom@gmail.com> Michael Droettboom <mdboom@debian-vm>
+
+Michiel de Hoon <mjldehoon@yahoo.com>
+Michiel de Hoon <mjldehoon@yahoo.com> Michiel de Hoon <mdehoon@mad002s-MacBook-Air.local>
+Michiel de Hoon <mjldehoon@yahoo.com> Michiel de Hoon <mdehoon@michiel-de-hoons-computer.local>
+Michiel de Hoon <mjldehoon@yahoo.com> Michiel de Hoon <mdehoon@Michiels-MacBook-Pro.local>
+Michiel de Hoon <mjldehoon@yahoo.com> Michiel de Hoon <mdehoon@tkx294.genome.gsc.riken.jp>
+
+MinRK <benjaminrk@gmail.com>
+MinRK <benjaminrk@gmail.com> Min RK <minrk@kerbin.local>
+
+Nelle Varoquaux <nelle.varoquaux@gmail.com>
+
+Nic Eggert <nic.eggert@gmail.com> Nic Eggert <nic@eggert.pw>
+Nic Eggert <nic.eggert@gmail.com> Nic Eggert <nse23@cornell.edu>
+
+Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+
+OceanWolf <juichenieder-tigger@yahoo.co.uk>
+
+Olivier Castany <1868182+ocastany@users.noreply.github.com>
+Olivier Castany <1868182+ocastany@users.noreply.github.com> <Olivier@home>
+Olivier Castany <1868182+ocastany@users.noreply.github.com> <castany@clevo>
+
+Om Sitapara <omsitapara23@gmail.com>
+
+Patrick Chen <pat.chen@mail.utoronto.ca>
+
+Paul Ganssle <p.ganssle@gmail.com>
+Paul Ganssle <pg@example.com>
+
+Paul Hobson <pmhobson@gmail.com>
+Paul Hobson <pmhobson@gmail.com> vagrant <vagrant@precise32.(none)>
+
+Paul Ivanov <pivanov314@gmail.com>
+Paul Ivanov <pivanov314@gmail.com> <pi@berkeley.edu>
+Paul Ivanov <pivanov314@gmail.com> <pivanov5@bloomberg.net>
+
+Per Parker <wisalam@live.com>
+
+Peter Würtz <pwuertz@gmail.com>
+Peter Würtz <pwuertz@gmail.com> <pwuertz@googlemail.com>
+
+Phil Elson <pelson.pub@gmail.com>
+Phil Elson <pelson.pub@gmail.com> <philipelson@hotmail.com>
+Phil Elson <pelson.pub@gmail.com> <philipelson@gmail.com>
+
+productivememberofsociety666 <productivememberofsociety666@sol.fr.am> none <none@example.net>
+
+Rishikesh <rishikksh20@gmail.com>
+
+RyanPan <ryanbelt1993129@hotmail.com>
+
+Samesh Lakhotia <samesh.lakhotia@gmail.com>
+Samesh Lakhotia <43701530+sameshl@users.noreply.github.com> <samesh.lakhotia@gmail.com>'
+
+Scott Lasley <selasley@me.com>
+
+Sebastian Raschka <mail@sebastianraschka.com>
+Sebastian Raschka <mail@sebastianraschka.com> <se.raschka@me.com>
+
+Sidharth Bansal <bansal.sidharth2996@gmail.com>
+Sidharth Bansal <20972099+SidharthBansal@users.noreply.github.com> <bansal.sidharth2996@gmail.com>
+
+Simon Cross <hodgestar+github@gmail.com> <hodgestar@gmail.com>
+
+Slav Basharov <slavbacharov@gmail.com>
+
+sohero <herosgq@gmail.com> sohero <ivip@tom.com>
+
+Stefan van der Walt <stefanv@berkeley.edu> <stefan@sun.ac.za>
+
+switham <github@mac-guyver.com> switham <switham_github@mac-guyver.com>
+
+Taehoon Lee <taehoonlee@snu.ac.kr>
+
+Ted Drain <ted.drain@gmail.com>
+
+Taras Kuzyo <kuzyo.taras@gmail.com>
+
+Terence Honles <terence@honles.com>
+
+Thomas A Caswell <tcaswell@gmail.com> Thomas A Caswell <tcaswell@bnl.gov>
+Thomas A Caswell <tcaswell@gmail.com> Thomas A Caswell <tcaswell@uchicago.edu>
+Thomas A Caswell <tcaswell@gmail.com> Thomas A Caswell <“tcaswell@gmail.com”>
+Thomas A Caswell <tcaswell@gmail.com> Thomas A Caswell <tcaswell@localhost.localdomain>
+
+Till Stensitzki <mail.till@gmx.de>
+
+Trish Gillett-Kawamoto <trish.gillett@shopify.com> <discardthree@gmail.com>
+
+Tuan Dung Tran <tuan.d.tran@hotmail.com>
+
+Víctor Zabalza <vzabalza@gmail.com>
+
+Vidur Satija <vidursatija@gmail.com>
+
+WANG Aiyong <gepcelway@gmail.com>
+
+Zhili (Jerry) Pan <sasori.pan.jerry@gmail.com>
+
+Werner F Bruhin <wernerfbd@gmx.ch>
+
+Yunfei Yang <yangyunf@iits-b473-20053.(none)> Yunfei Yang <yangyunf@iits-b473-20057.(none)>
+Yunfei Yang <yangyunf@iits-b473-20053.(none)> Yunfei Yang <yangyunf@iits-b473-20061.(none)>
+
+Zac Hatfield-Dodds <zac.hatfield.dodds@gmail.com>

testbed/matplotlib__matplotlib/.matplotlib-repo

@@ -0,0 +1,3 @@
+The existence of this file signals that the code is a matplotlib source repo
+and not an installed version. We use this in __init__.py for gating version
+detection.

testbed/matplotlib__matplotlib/.meeseeksdev.yml

@@ -0,0 +1,4 @@
+users:
+  Carreau:
+    can:
+      - backport

testbed/matplotlib__matplotlib/.pre-commit-config.yaml

@@ -0,0 +1,53 @@
+ci:
+  autofix_prs: false
+  autoupdate_schedule: 'quarterly'
+exclude: |
+  (?x)^(
+    extern|
+    LICENSE|
+    lib/matplotlib/mpl-data|
+    doc/devel/gitwash|
+    doc/users/prev|
+    doc/api/prev|
+    lib/matplotlib/tests/tinypages
+    )
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-docstring-first
+        exclude: lib/matplotlib/typing.py  # docstring used for attribute flagged by check
+      - id: end-of-file-fixer
+        exclude_types: [svg]
+      - id: mixed-line-ending
+      - id: name-tests-test
+        args: ["--pytest-test-first"]
+      - id: no-commit-to-branch #default is master and main
+      - id: trailing-whitespace
+        exclude_types: [svg]
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 6.0.0
+    hooks:
+      - id: flake8
+        additional_dependencies: [pydocstyle>5.1.0, flake8-docstrings>1.4.0, flake8-force]
+        args: ["--docstring-convention=all"]
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.4
+    hooks:
+      - id: codespell
+        files: ^.*\.(py|c|cpp|h|m|md|rst|yml)$
+        args: [
+          "--ignore-words",
+          "ci/codespell-ignore-words.txt",
+          "--skip",
+          "doc/users/project/credits.rst"
+          ]
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        name: isort (python)
+        files: ^galleries/tutorials/|^galleries/examples/|^galleries/plot_types/

testbed/matplotlib__matplotlib/CITATION.bib

@@ -0,0 +1,14 @@
+@Article{Hunter:2007,
+  Author    = {Hunter, J. D.},
+  Title     = {Matplotlib: A 2D graphics environment},
+  Journal   = {Computing in Science \& Engineering},
+  Volume    = {9},
+  Number    = {3},
+  Pages     = {90--95},
+  abstract  = {Matplotlib is a 2D graphics package used for Python for
+  application development, interactive scripting, and publication-quality
+  image generation across user interfaces and operating systems.},
+  publisher = {IEEE COMPUTER SOC},
+  doi       = {10.1109/MCSE.2007.55},
+  year      = 2007
+}

testbed/matplotlib__matplotlib/CITATION.cff

@@ -0,0 +1,27 @@
+cff-version: 1.2.0
+message: 'If Matplotlib contributes to a project that leads to a scientific publication, please acknowledge this fact by citing J. D. Hunter, "Matplotlib: A 2D Graphics Environment", Computing in Science & Engineering, vol. 9, no. 3, pp. 90-95, 2007.'
+title: 'Matplotlib: Visualization with Python'
+authors:
+  - name: The Matplotlib Development Team
+    website: https://matplotlib.org/
+type: software
+url: 'https://matplotlib.org/'
+repository-code: 'https://github.com/matplotlib/matplotlib/'
+preferred-citation:
+  type: article
+  authors:
+    - family-names: Hunter
+      given-names: John D.
+  title: "Matplotlib: A 2D graphics environment"
+  year: 2007
+  date-published: 2007-06-18
+  journal: Computing in Science & Engineering
+  volume: 9
+  issue: 3
+  start: 90
+  end: 95
+  doi: 10.1109/MCSE.2007.55
+  publisher:
+    name: IEEE Computer Society
+    website: 'https://www.computer.org/'
+  abstract: Matplotlib is a 2D graphics package used for Python for application development, interactive scripting, and publication-quality image generation across user interfaces and operating systems.

testbed/matplotlib__matplotlib/CODE_OF_CONDUCT.md

@@ -0,0 +1,136 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[matplotlib-coc@numfocus.org](mailto:matplotlib-coc@numfocus.org)
+(monitored by the [CoC subcommittee](https://matplotlib.org/governance/people.html#coc-subcommittee)) or a
+report can be made using the [NumFOCUS Code of Conduct report form][numfocus
+form].  If community leaders cannot come to a resolution about enforcement,
+reports will be escalated to the NumFocus Code of Conduct committee
+(conduct@numfocus.org).  All complaints will be reviewed and investigated
+promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+[numfocus form]: https://numfocus.typeform.com/to/ynjGdT
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

testbed/matplotlib__matplotlib/INSTALL.rst

@@ -0,0 +1 @@
+See doc/users/installing/index.rst

testbed/matplotlib__matplotlib/README.md

@@ -0,0 +1,73 @@
+[![PyPi](https://img.shields.io/pypi/v/matplotlib)](https://pypi.org/project/matplotlib/)
+[![Conda](https://img.shields.io/conda/vn/conda-forge/matplotlib)](https://anaconda.org/conda-forge/matplotlib)
+[![Downloads](https://img.shields.io/pypi/dm/matplotlib)](https://pypi.org/project/matplotlib)
+[![NUMFocus](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
+
+[![Discourse help forum](https://img.shields.io/badge/help_forum-discourse-blue.svg)](https://discourse.matplotlib.org)
+[![Gitter](https://badges.gitter.im/matplotlib/matplotlib.svg)](https://gitter.im/matplotlib/matplotlib)
+[![GitHub issues](https://img.shields.io/badge/issue_tracking-github-blue.svg)](https://github.com/matplotlib/matplotlib/issues)
+[![Contributing](https://img.shields.io/badge/PR-Welcome-%23FF8300.svg?)](https://matplotlib.org/stable/devel/index.html)
+
+[![GitHub actions status](https://github.com/matplotlib/matplotlib/workflows/Tests/badge.svg)](https://github.com/matplotlib/matplotlib/actions?query=workflow%3ATests)
+[![Azure pipelines status](https://dev.azure.com/matplotlib/matplotlib/_apis/build/status/matplotlib.matplotlib?branchName=main)](https://dev.azure.com/matplotlib/matplotlib/_build/latest?definitionId=1&branchName=main)
+[![AppVeyor status](https://ci.appveyor.com/api/projects/status/github/matplotlib/matplotlib?branch=main&svg=true)](https://ci.appveyor.com/project/matplotlib/matplotlib)
+[![Codecov status](https://codecov.io/github/matplotlib/matplotlib/badge.svg?branch=main&service=github)](https://app.codecov.io/gh/matplotlib/matplotlib)
+
+![Matplotlib logotype](https://matplotlib.org/_static/logo2.svg)
+
+Matplotlib is a comprehensive library for creating static, animated, and
+interactive visualizations in Python.
+
+Check out our [home page](https://matplotlib.org/) for more information.
+
+![image](https://matplotlib.org/_static/readme_preview.png)
+
+Matplotlib produces publication-quality figures in a variety of hardcopy
+formats and interactive environments across platforms. Matplotlib can be
+used in Python scripts, Python/IPython shells, web application servers,
+and various graphical user interface toolkits.
+
+## Install
+
+See the [install
+documentation](https://matplotlib.org/stable/users/installing/index.html),
+which is generated from `/doc/users/installing/index.rst`
+
+## Contribute
+
+You've discovered a bug or something else you want to change — excellent!
+
+You've worked out a way to fix it — even better!
+
+You want to tell us about it — best of all!
+
+Start at the [contributing
+guide](https://matplotlib.org/devdocs/devel/contributing.html)!
+
+## Contact
+
+[Discourse](https://discourse.matplotlib.org/) is the discussion forum
+for general questions and discussions and our recommended starting
+point.
+
+Our active mailing lists (which are mirrored on Discourse) are:
+
+-   [Users](https://mail.python.org/mailman/listinfo/matplotlib-users)
+    mailing list: <matplotlib-users@python.org>
+-   [Announcement](https://mail.python.org/mailman/listinfo/matplotlib-announce)
+    mailing list: <matplotlib-announce@python.org>
+-   [Development](https://mail.python.org/mailman/listinfo/matplotlib-devel)
+    mailing list: <matplotlib-devel@python.org>
+
+[Gitter](https://gitter.im/matplotlib/matplotlib) is for coordinating
+development and asking questions directly related to contributing to
+matplotlib.
+
+## Citing Matplotlib
+
+If Matplotlib contributes to a project that leads to publication, please
+acknowledge this by citing Matplotlib.
+
+[A ready-made citation
+entry](https://matplotlib.org/stable/users/project/citing.html) is
+available.

testbed/matplotlib__matplotlib/SECURITY.md

@@ -0,0 +1,29 @@
+# Security Policy
+
+## Supported Versions
+
+The following table lists versions and whether they are supported. Security
+vulnerability reports will be accepted and acted upon for all supported
+versions.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 3.7.x   | :white_check_mark: |
+| 3.6.x   | :white_check_mark: |
+| 3.5.x   | :x:                |
+| 3.4.x   | :x:                |
+| 3.3.x   | :x:                |
+| < 3.3   | :x:                |
+
+
+## Reporting a Vulnerability
+
+
+To report a security vulnerability, please use the [Tidelift security
+contact](https://tidelift.com/security).  Tidelift will coordinate the fix and
+disclosure.
+
+If you have found a security vulnerability, in order to keep it confidential,
+please do not report an issue on GitHub.
+
+We do not award bounties for security vulnerabilities.

testbed/matplotlib__matplotlib/azure-pipelines.yml

@@ -0,0 +1,165 @@
+# Python package
+# Create and test a Python package on multiple Python versions.
+# Add steps that analyze code, save the dist with the build record, publish to a PyPI-compatible index, and more:
+# https://docs.microsoft.com/en-us/azure/devops/pipelines/ecosystems/python?view=azure-devops
+
+trigger:
+  branches:
+    exclude:
+      - v*-doc
+pr:
+  branches:
+    exclude:
+      - v*-doc
+  paths:
+    exclude:
+      - doc/**/*
+      - galleries/**/*
+
+stages:
+
+- stage: Check
+  jobs:
+  - job: Skip
+    pool:
+      vmImage: 'ubuntu-latest'
+    variables:
+      DECODE_PERCENTS: 'false'
+      RET: 'true'
+    steps:
+    - bash: |
+        git_log=`git log --max-count=1 --skip=1 --pretty=format:"%B" | tr "\n" " "`
+        echo "##vso[task.setvariable variable=log]$git_log"
+    - bash: echo "##vso[task.setvariable variable=RET]false"
+      condition: or(contains(variables.log, '[skip azp]'), contains(variables.log, '[azp skip]'), contains(variables.log, '[skip ci]'), contains(variables.log, '[ci skip]'), contains(variables.log, '[ci doc]'))
+    - bash: echo "##vso[task.setvariable variable=start_main;isOutput=true]$RET"
+      name: result
+
+- stage: Main
+  condition: and(succeeded(), eq(dependencies.Check.outputs['Skip.result.start_main'], 'true'))
+  dependsOn: Check
+  jobs:
+    - job: Pytest
+      strategy:
+        matrix:
+          Linux_py39:
+            vmImage: 'ubuntu-20.04'  # keep one job pinned to the oldest image
+            python.version: '3.9'
+          Linux_py310:
+            vmImage: 'ubuntu-latest'
+            python.version: '3.10'
+          Linux_py311:
+            vmImage: 'ubuntu-latest'
+            python.version: '3.11'
+          macOS_py39:
+            vmImage: 'macOS-latest'
+            python.version: '3.9'
+          macOS_py310:
+            vmImage: 'macOS-latest'
+            python.version: '3.10'
+          macOS_py311:
+            vmImage: 'macOS-latest'
+            python.version: '3.11'
+          Windows_py39:
+            vmImage: 'windows-2019'  # keep one job pinned to the oldest image
+            python.version: '3.9'
+          Windows_py310:
+            vmImage: 'windows-latest'
+            python.version: '3.10'
+          Windows_py311:
+            vmImage: 'windows-latest'
+            python.version: '3.11'
+        maxParallel: 4
+      pool:
+        vmImage: '$(vmImage)'
+      steps:
+      - task: UsePythonVersion@0
+        inputs:
+          versionSpec: '$(python.version)'
+          architecture: 'x64'
+        displayName: 'Use Python $(python.version)'
+        condition: and(succeeded(), ne(variables['python.version'], 'Pre'))
+
+      - task: stevedower.python.InstallPython.InstallPython@1
+        displayName: 'Use prerelease Python'
+        inputs:
+          prerelease: true
+        condition: and(succeeded(), eq(variables['python.version'], 'Pre'))
+
+      - bash: |
+          set -e
+          case "$(python -c 'import sys; print(sys.platform)')" in
+          linux)
+            echo 'Acquire::Retries "3";' | sudo tee /etc/apt/apt.conf.d/80-retries
+            sudo apt update
+            sudo apt install \
+              cm-super \
+              dvipng \
+              ffmpeg \
+              fonts-noto-cjk \
+              gdb \
+              gir1.2-gtk-3.0 \
+              graphviz \
+              inkscape \
+              libcairo2 \
+              libgirepository-1.0-1 \
+              lmodern \
+              fonts-freefont-otf \
+              poppler-utils \
+              texlive-pictures \
+              texlive-fonts-recommended \
+              texlive-latex-base \
+              texlive-latex-extra \
+              texlive-latex-recommended \
+              texlive-xetex texlive-luatex \
+              ttf-wqy-zenhei
+            ;;
+          darwin)
+            brew install --cask xquartz
+            brew install pkg-config ffmpeg imagemagick mplayer ccache
+            brew tap homebrew/cask-fonts
+            brew install font-noto-sans-cjk-sc
+            ;;
+          win32)
+            ;;
+          *)
+            exit 1
+            ;;
+          esac
+        displayName: 'Install dependencies'
+
+      - bash: |
+          python -m pip install --upgrade pip
+          python -m pip install -r requirements/testing/all.txt -r requirements/testing/extra.txt ||
+            [[ "$PYTHON_VERSION" = 'Pre' ]]
+        displayName: 'Install dependencies with pip'
+
+      - bash: |
+          python -m pip install -ve . ||
+            [[ "$PYTHON_VERSION" = 'Pre' ]]
+        displayName: "Install self"
+
+      - script: env
+        displayName: 'print env'
+
+      - script: pip list
+        displayName: 'print pip'
+
+      - bash: |
+          PYTHONFAULTHANDLER=1 python -m pytest --junitxml=junit/test-results.xml -raR --maxfail=50 --timeout=300 --durations=25 --cov-report= --cov=lib -n 2 ||
+            [[ "$PYTHON_VERSION" = 'Pre' ]]
+        displayName: 'pytest'
+
+      - bash: |
+          bash <(curl -s https://codecov.io/bash)  -f "!*.gcov" -X gcov
+        displayName: 'Upload to codecov.io'
+
+      - task: PublishTestResults@2
+        inputs:
+          testResultsFiles: '**/test-results.xml'
+          testRunTitle: 'Python $(python.version)'
+        condition: succeededOrFailed()
+
+      - publish: $(System.DefaultWorkingDirectory)/result_images
+        artifact: $(Agent.JobName)-result_images
+        condition: and(failed(), ne(variables['python.version'], 'Pre'))

testbed/matplotlib__matplotlib/environment.yml

@@ -0,0 +1,65 @@
+# To set up a development environment using conda run:
+#
+#   conda env create -f environment.yml
+#   conda activate mpl-dev
+#   pip install -e .
+#
+name: mpl-dev
+channels:
+  - conda-forge
+dependencies:
+  # runtime dependencies
+  - cairocffi
+  - contourpy>=1.0.1
+  - cycler>=0.10.0
+  - fonttools>=4.22.0
+  - importlib-resources>=3.2.0
+  - kiwisolver>=1.0.1
+  - numpy>=1.21
+  - pillow>=6.2
+  - pybind11>=2.6.0
+  - pygobject
+  - pyparsing>=2.3.1
+  - pyqt
+  - python-dateutil>=2.1
+  - setuptools
+  - setuptools_scm
+  - wxpython
+  # building documentation
+  - colorspacious
+  - graphviz
+  - ipython
+  - ipywidgets
+  - numpydoc>=0.8
+  - packaging
+  - pydata-sphinx-theme
+  - pyyaml
+  - sphinx>=1.8.1,!=2.0.0
+  - sphinx-copybutton
+  - sphinx-gallery>=0.12
+  - sphinx-design
+  - pip
+  - pip:
+      - mpl-sphinx-theme
+      - sphinxcontrib-svg2pdfconverter
+      - pikepdf
+  # testing
+  - coverage
+  - flake8>=3.8
+  - flake8-docstrings>=1.4.0
+  - gtk4
+  - ipykernel
+  - nbconvert[execute]!=6.0.0,!=6.0.1,!=7.3.0,!=7.3.1
+  - nbformat!=5.0.0,!=5.0.1
+  - pandas!=0.25.0
+  - psutil
+  - pre-commit
+  - pydocstyle>=5.1.0
+  - pytest!=4.6.0,!=5.4.0
+  - pytest-cov
+  - pytest-rerunfailures
+  - pytest-timeout
+  - pytest-xdist
+  - tornado
+  - pytz
+  - black

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/README.txt

@@ -0,0 +1,4 @@
+.. _subplots_axes_and_figures_examples:
+
+Subplots, axes and figures
+==========================

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/axes_zoom_effect.py

@@ -0,0 +1,122 @@
+"""
+================
+Axes Zoom Effect
+================
+
+"""
+
+import matplotlib.pyplot as plt
+
+from matplotlib.transforms import (Bbox, TransformedBbox,
+                                   blended_transform_factory)
+from mpl_toolkits.axes_grid1.inset_locator import (BboxConnector,
+                                                   BboxConnectorPatch,
+                                                   BboxPatch)
+
+
+def connect_bbox(bbox1, bbox2,
+                 loc1a, loc2a, loc1b, loc2b,
+                 prop_lines, prop_patches=None):
+    if prop_patches is None:
+        prop_patches = {
+            **prop_lines,
+            "alpha": prop_lines.get("alpha", 1) * 0.2,
+            "clip_on": False,
+        }
+
+    c1 = BboxConnector(
+        bbox1, bbox2, loc1=loc1a, loc2=loc2a, clip_on=False, **prop_lines)
+    c2 = BboxConnector(
+        bbox1, bbox2, loc1=loc1b, loc2=loc2b, clip_on=False, **prop_lines)
+
+    bbox_patch1 = BboxPatch(bbox1, **prop_patches)
+    bbox_patch2 = BboxPatch(bbox2, **prop_patches)
+
+    p = BboxConnectorPatch(bbox1, bbox2,
+                           loc1a=loc1a, loc2a=loc2a, loc1b=loc1b, loc2b=loc2b,
+                           clip_on=False,
+                           **prop_patches)
+
+    return c1, c2, bbox_patch1, bbox_patch2, p
+
+
+def zoom_effect01(ax1, ax2, xmin, xmax, **kwargs):
+    """
+    Connect *ax1* and *ax2*. The *xmin*-to-*xmax* range in both axes will
+    be marked.
+
+    Parameters
+    ----------
+    ax1
+        The main axes.
+    ax2
+        The zoomed axes.
+    xmin, xmax
+        The limits of the colored area in both plot axes.
+    **kwargs
+        Arguments passed to the patch constructor.
+    """
+
+    bbox = Bbox.from_extents(xmin, 0, xmax, 1)
+
+    mybbox1 = TransformedBbox(bbox, ax1.get_xaxis_transform())
+    mybbox2 = TransformedBbox(bbox, ax2.get_xaxis_transform())
+
+    prop_patches = {**kwargs, "ec": "none", "alpha": 0.2}
+
+    c1, c2, bbox_patch1, bbox_patch2, p = connect_bbox(
+        mybbox1, mybbox2,
+        loc1a=3, loc2a=2, loc1b=4, loc2b=1,
+        prop_lines=kwargs, prop_patches=prop_patches)
+
+    ax1.add_patch(bbox_patch1)
+    ax2.add_patch(bbox_patch2)
+    ax2.add_patch(c1)
+    ax2.add_patch(c2)
+    ax2.add_patch(p)
+
+    return c1, c2, bbox_patch1, bbox_patch2, p
+
+
+def zoom_effect02(ax1, ax2, **kwargs):
+    """
+    ax1 : the main axes
+    ax1 : the zoomed axes
+
+    Similar to zoom_effect01.  The xmin & xmax will be taken from the
+    ax1.viewLim.
+    """
+
+    tt = ax1.transScale + (ax1.transLimits + ax2.transAxes)
+    trans = blended_transform_factory(ax2.transData, tt)
+
+    mybbox1 = ax1.bbox
+    mybbox2 = TransformedBbox(ax1.viewLim, trans)
+
+    prop_patches = {**kwargs, "ec": "none", "alpha": 0.2}
+
+    c1, c2, bbox_patch1, bbox_patch2, p = connect_bbox(
+        mybbox1, mybbox2,
+        loc1a=3, loc2a=2, loc1b=4, loc2b=1,
+        prop_lines=kwargs, prop_patches=prop_patches)
+
+    ax1.add_patch(bbox_patch1)
+    ax2.add_patch(bbox_patch2)
+    ax2.add_patch(c1)
+    ax2.add_patch(c2)
+    ax2.add_patch(p)
+
+    return c1, c2, bbox_patch1, bbox_patch2, p
+
+
+axs = plt.figure().subplot_mosaic([
+    ["zoom1", "zoom2"],
+    ["main", "main"],
+])
+
+axs["main"].set(xlim=(0, 5))
+zoom_effect01(axs["zoom1"], axs["main"], 0.2, 0.8)
+axs["zoom2"].set(xlim=(2, 3))
+zoom_effect02(axs["zoom2"], axs["main"])
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/axhspan_demo.py

@@ -0,0 +1,36 @@
+"""
+============
+axhspan Demo
+============
+
+Create lines or rectangles that span the axes in either the horizontal or
+vertical direction, and lines than span the axes with an arbitrary orientation.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+t = np.arange(-1, 2, .01)
+s = np.sin(2 * np.pi * t)
+
+fig, ax = plt.subplots()
+
+ax.plot(t, s)
+# Thick red horizontal line at y=0 that spans the xrange.
+ax.axhline(linewidth=8, color='#d62728')
+# Horizontal line at y=1 that spans the xrange.
+ax.axhline(y=1)
+# Vertical line at x=1 that spans the yrange.
+ax.axvline(x=1)
+# Thick blue vertical line at x=0 that spans the upper quadrant of the yrange.
+ax.axvline(x=0, ymin=0.75, linewidth=8, color='#1f77b4')
+# Default hline at y=.5 that spans the middle half of the axes.
+ax.axhline(y=.5, xmin=0.25, xmax=0.75)
+# Infinite black line going through (0, 0) to (1, 1).
+ax.axline((0, 0), (1, 1), color='k')
+# 50%-gray rectangle spanning the axes' width from y=0.25 to y=0.75.
+ax.axhspan(0.25, 0.75, facecolor='0.5')
+# Green rectangle spanning the axes' height from x=1.25 to x=1.55.
+ax.axvspan(1.25, 1.55, facecolor='#2ca02c')
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/axis_equal_demo.py

@@ -0,0 +1,35 @@
+"""
+=======================
+Equal axis aspect ratio
+=======================
+
+How to set and adjust plots with equal axis aspect ratios.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Plot circle of radius 3.
+
+an = np.linspace(0, 2 * np.pi, 100)
+fig, axs = plt.subplots(2, 2)
+
+axs[0, 0].plot(3 * np.cos(an), 3 * np.sin(an))
+axs[0, 0].set_title('not equal, looks like ellipse', fontsize=10)
+
+axs[0, 1].plot(3 * np.cos(an), 3 * np.sin(an))
+axs[0, 1].axis('equal')
+axs[0, 1].set_title('equal, looks like circle', fontsize=10)
+
+axs[1, 0].plot(3 * np.cos(an), 3 * np.sin(an))
+axs[1, 0].axis('equal')
+axs[1, 0].set(xlim=(-3, 3), ylim=(-3, 3))
+axs[1, 0].set_title('still a circle, even after changing limits', fontsize=10)
+
+axs[1, 1].plot(3 * np.cos(an), 3 * np.sin(an))
+axs[1, 1].set_aspect('equal', 'box')
+axs[1, 1].set_title('still a circle, auto-adjusted data limits', fontsize=10)
+
+fig.tight_layout()
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/axis_labels_demo.py

@@ -0,0 +1,20 @@
+"""
+===================
+Axis Label Position
+===================
+
+Choose axis label position when calling `~.Axes.set_xlabel` and
+`~.Axes.set_ylabel` as well as for colorbar.
+
+"""
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots()
+
+sc = ax.scatter([1, 2], [1, 2], c=[1, 2])
+ax.set_ylabel('YLabel', loc='top')
+ax.set_xlabel('XLabel', loc='left')
+cbar = fig.colorbar(sc)
+cbar.set_label("ZLabel", loc='top')
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/custom_figure_class.py

@@ -0,0 +1,52 @@
+"""
+========================
+Custom Figure subclasses
+========================
+
+You can pass a `.Figure` subclass to `.pyplot.figure` if you want to change
+the default behavior of the figure.
+
+This example defines a `.Figure` subclass ``WatermarkFigure`` that accepts an
+additional parameter ``watermark`` to display a custom watermark text. The
+figure is created using the ``FigureClass`` parameter of `.pyplot.figure`.
+The additional ``watermark`` parameter is passed on to the subclass
+constructor.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from matplotlib.figure import Figure
+
+
+class WatermarkFigure(Figure):
+    """A figure with a text watermark."""
+
+    def __init__(self, *args, watermark=None, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if watermark is not None:
+            bbox = dict(boxstyle='square', lw=3, ec='gray',
+                        fc=(0.9, 0.9, .9, .5), alpha=0.5)
+            self.text(0.5, 0.5, watermark,
+                      ha='center', va='center', rotation=30,
+                      fontsize=40, color='gray', alpha=0.5, bbox=bbox)
+
+
+x = np.linspace(-3, 3, 201)
+y = np.tanh(x) + 0.1 * np.cos(5 * x)
+
+plt.figure(FigureClass=WatermarkFigure, watermark='draft')
+plt.plot(x, y)
+
+
+# %%
+#
+# .. admonition:: References
+#
+#    The use of the following functions, methods, classes and modules is shown
+#    in this example:
+#
+#    - `matplotlib.pyplot.figure`
+#    - `matplotlib.figure.Figure`
+#    - `matplotlib.figure.Figure.text`

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/demo_tight_layout.py

@@ -0,0 +1,134 @@
+"""
+===============================
+Resizing axes with tight layout
+===============================
+
+`~.Figure.tight_layout` attempts to resize subplots in a figure so that there
+are no overlaps between axes objects and labels on the axes.
+
+See :ref:`tight_layout_guide` for more details and
+:ref:`constrainedlayout_guide` for an alternative.
+
+"""
+
+import itertools
+import warnings
+
+import matplotlib.pyplot as plt
+
+fontsizes = itertools.cycle([8, 16, 24, 32])
+
+
+def example_plot(ax):
+    ax.plot([1, 2])
+    ax.set_xlabel('x-label', fontsize=next(fontsizes))
+    ax.set_ylabel('y-label', fontsize=next(fontsizes))
+    ax.set_title('Title', fontsize=next(fontsizes))
+
+
+# %%
+
+fig, ax = plt.subplots()
+example_plot(ax)
+fig.tight_layout()
+
+# %%
+
+fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2)
+example_plot(ax1)
+example_plot(ax2)
+example_plot(ax3)
+example_plot(ax4)
+fig.tight_layout()
+
+# %%
+
+fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1)
+example_plot(ax1)
+example_plot(ax2)
+fig.tight_layout()
+
+# %%
+
+fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)
+example_plot(ax1)
+example_plot(ax2)
+fig.tight_layout()
+
+# %%
+
+fig, axs = plt.subplots(nrows=3, ncols=3)
+for ax in axs.flat:
+    example_plot(ax)
+fig.tight_layout()
+
+# %%
+
+plt.figure()
+ax1 = plt.subplot(221)
+ax2 = plt.subplot(223)
+ax3 = plt.subplot(122)
+example_plot(ax1)
+example_plot(ax2)
+example_plot(ax3)
+plt.tight_layout()
+
+# %%
+
+plt.figure()
+ax1 = plt.subplot2grid((3, 3), (0, 0))
+ax2 = plt.subplot2grid((3, 3), (0, 1), colspan=2)
+ax3 = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=2)
+ax4 = plt.subplot2grid((3, 3), (1, 2), rowspan=2)
+example_plot(ax1)
+example_plot(ax2)
+example_plot(ax3)
+example_plot(ax4)
+plt.tight_layout()
+
+# %%
+
+fig = plt.figure()
+
+gs1 = fig.add_gridspec(3, 1)
+ax1 = fig.add_subplot(gs1[0])
+ax2 = fig.add_subplot(gs1[1])
+ax3 = fig.add_subplot(gs1[2])
+example_plot(ax1)
+example_plot(ax2)
+example_plot(ax3)
+gs1.tight_layout(fig, rect=[None, None, 0.45, None])
+
+gs2 = fig.add_gridspec(2, 1)
+ax4 = fig.add_subplot(gs2[0])
+ax5 = fig.add_subplot(gs2[1])
+example_plot(ax4)
+example_plot(ax5)
+with warnings.catch_warnings():
+    # gs2.tight_layout cannot handle the subplots from the first gridspec
+    # (gs1), so it will raise a warning. We are going to match the gridspecs
+    # manually so we can filter the warning away.
+    warnings.simplefilter("ignore", UserWarning)
+    gs2.tight_layout(fig, rect=[0.45, None, None, None])
+
+# now match the top and bottom of two gridspecs.
+top = min(gs1.top, gs2.top)
+bottom = max(gs1.bottom, gs2.bottom)
+
+gs1.update(top=top, bottom=bottom)
+gs2.update(top=top, bottom=bottom)
+
+plt.show()
+
+# %%
+#
+# .. admonition:: References
+#
+#    The use of the following functions, methods, classes and modules is shown
+#    in this example:
+#
+#    - `matplotlib.figure.Figure.tight_layout` /
+#      `matplotlib.pyplot.tight_layout`
+#    - `matplotlib.figure.Figure.add_gridspec`
+#    - `matplotlib.figure.Figure.add_subplot`
+#    - `matplotlib.pyplot.subplot2grid`

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/gridspec_nested.py

@@ -0,0 +1,46 @@
+"""
+================
+Nested Gridspecs
+================
+
+GridSpecs can be nested, so that a subplot from a parent GridSpec can
+set the position for a nested grid of subplots.
+
+Note that the same functionality can be achieved more directly with
+`~.FigureBase.subfigures`; see
+:doc:`/gallery/subplots_axes_and_figures/subfigures`.
+
+"""
+import matplotlib.pyplot as plt
+
+import matplotlib.gridspec as gridspec
+
+
+def format_axes(fig):
+    for i, ax in enumerate(fig.axes):
+        ax.text(0.5, 0.5, "ax%d" % (i+1), va="center", ha="center")
+        ax.tick_params(labelbottom=False, labelleft=False)
+
+
+# gridspec inside gridspec
+fig = plt.figure()
+
+gs0 = gridspec.GridSpec(1, 2, figure=fig)
+
+gs00 = gridspec.GridSpecFromSubplotSpec(3, 3, subplot_spec=gs0[0])
+
+ax1 = fig.add_subplot(gs00[:-1, :])
+ax2 = fig.add_subplot(gs00[-1, :-1])
+ax3 = fig.add_subplot(gs00[-1, -1])
+
+# the following syntax does the same as the GridSpecFromSubplotSpec call above:
+gs01 = gs0[1].subgridspec(3, 3)
+
+ax4 = fig.add_subplot(gs01[:, :-1])
+ax5 = fig.add_subplot(gs01[:-1, -1])
+ax6 = fig.add_subplot(gs01[-1, -1])
+
+plt.suptitle("GridSpec Inside GridSpec")
+format_axes(fig)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/multiple_figs_demo.py

@@ -0,0 +1,51 @@
+"""
+===================================
+Managing multiple figures in pyplot
+===================================
+
+`matplotlib.pyplot` uses the concept of a *current figure* and *current axes*.
+Figures are identified via a figure number that is passed to `~.pyplot.figure`.
+The figure with the given number is set as *current figure*. Additionally, if
+no figure with the number exists, a new one is created.
+
+.. note::
+
+    We discourage working with multiple figures through the implicit pyplot
+    interface because managing the *current figure* is cumbersome and
+    error-prone. Instead, we recommend using the explicit approach and call
+    methods on Figure and Axes instances. See :ref:`api_interfaces` for an
+    explanation of the trade-offs between the implicit and explicit interfaces.
+
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+t = np.arange(0.0, 2.0, 0.01)
+s1 = np.sin(2*np.pi*t)
+s2 = np.sin(4*np.pi*t)
+
+# %%
+# Create figure 1
+
+plt.figure(1)
+plt.subplot(211)
+plt.plot(t, s1)
+plt.subplot(212)
+plt.plot(t, 2*s1)
+
+# %%
+# Create figure 2
+
+plt.figure(2)
+plt.plot(t, s2)
+
+# %%
+# Now switch back to figure 1 and make some changes
+
+plt.figure(1)
+plt.subplot(211)
+plt.plot(t, s2, 's')
+ax = plt.gca()
+ax.set_xticklabels([])
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/subplots_axes_and_figures/subplot.py

@@ -0,0 +1,51 @@
+"""
+=================
+Multiple subplots
+=================
+
+Simple demo with multiple subplots.
+
+For more options, see :doc:`/gallery/subplots_axes_and_figures/subplots_demo`.
+
+.. redirect-from:: /gallery/subplots_axes_and_figures/subplot_demo
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Create some fake data.
+x1 = np.linspace(0.0, 5.0)
+y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)
+x2 = np.linspace(0.0, 2.0)
+y2 = np.cos(2 * np.pi * x2)
+
+# %%
+# `~.pyplot.subplots()` is the recommended method to generate simple subplot
+# arrangements:
+
+fig, (ax1, ax2) = plt.subplots(2, 1)
+fig.suptitle('A tale of 2 subplots')
+
+ax1.plot(x1, y1, 'o-')
+ax1.set_ylabel('Damped oscillation')
+
+ax2.plot(x2, y2, '.-')
+ax2.set_xlabel('time (s)')
+ax2.set_ylabel('Undamped')
+
+plt.show()
+
+# %%
+# Subplots can also be generated one at a time using `~.pyplot.subplot()`:
+
+plt.subplot(2, 1, 1)
+plt.plot(x1, y1, 'o-')
+plt.title('A tale of 2 subplots')
+plt.ylabel('Damped oscillation')
+
+plt.subplot(2, 1, 2)
+plt.plot(x2, y2, '.-')
+plt.xlabel('time (s)')
+plt.ylabel('Undamped')
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/text_labels_and_annotations/fancytextbox_demo.py

@@ -0,0 +1,26 @@
+"""
+==================
+Styling text boxes
+==================
+
+This example shows how to style text boxes using *bbox* parameters.
+"""
+import matplotlib.pyplot as plt
+
+plt.text(0.6, 0.7, "eggs", size=50, rotation=30.,
+         ha="center", va="center",
+         bbox=dict(boxstyle="round",
+                   ec=(1., 0.5, 0.5),
+                   fc=(1., 0.8, 0.8),
+                   )
+         )
+
+plt.text(0.55, 0.6, "spam", size=50, rotation=-25.,
+         ha="right", va="top",
+         bbox=dict(boxstyle="square",
+                   ec=(1., 0.5, 0.5),
+                   fc=(1., 0.8, 0.8),
+                   )
+         )
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/examples/text_labels_and_annotations/mathtext_demo.py

@@ -0,0 +1,26 @@
+"""
+========
+Mathtext
+========
+
+Use Matplotlib's internal LaTeX parser and layout engine.  For true LaTeX
+rendering, see the text.usetex option.
+"""
+
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots()
+
+ax.plot([1, 2, 3], label=r'$\sqrt{x^2}$')
+ax.legend()
+
+ax.set_xlabel(r'$\Delta_i^j$', fontsize=20)
+ax.set_ylabel(r'$\Delta_{i+1}^j$', fontsize=20)
+ax.set_title(r'$\Delta_i^j \hspace{0.4} \mathrm{versus} \hspace{0.4} '
+             r'\Delta_{i+1}^j$', fontsize=20)
+
+tex = r'$\mathcal{R}\prod_{i=\alpha_{i+1}}^\infty a_i\sin(2 \pi f x_i)$'
+ax.text(1, 1.6, tex, fontsize=20, va='bottom')
+
+fig.tight_layout()
+plt.show()

testbed/matplotlib__matplotlib/galleries/plot_types/README.rst

@@ -0,0 +1,11 @@
+.. _plot_types:
+
+.. redirect-from:: /tutorials/basic/sample_plots
+
+Plot types
+==========
+
+Overview of many common plotting commands provided by Matplotlib.
+
+See the `gallery <../gallery/index.html>`_ for more examples and
+the `tutorials page <../tutorials/index.html>`_ for longer examples.

testbed/matplotlib__matplotlib/galleries/plot_types/stats/hist2d.py

@@ -0,0 +1,25 @@
+"""
+============
+hist2d(x, y)
+============
+
+See `~matplotlib.axes.Axes.hist2d`.
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+plt.style.use('_mpl-gallery-nogrid')
+
+# make data: correlated + noise
+np.random.seed(1)
+x = np.random.randn(5000)
+y = 1.2 * x + np.random.randn(5000) / 3
+
+# plot:
+fig, ax = plt.subplots()
+
+ax.hist2d(x, y, bins=(np.arange(-3, 3, 0.1), np.arange(-3, 3, 0.1)))
+
+ax.set(xlim=(-2, 2), ylim=(-3, 3))
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/plot_types/stats/pie.py

@@ -0,0 +1,26 @@
+"""
+======
+pie(x)
+======
+
+See `~matplotlib.axes.Axes.pie`.
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+plt.style.use('_mpl-gallery-nogrid')
+
+
+# make data
+x = [1, 2, 3, 4]
+colors = plt.get_cmap('Blues')(np.linspace(0.2, 0.7, len(x)))
+
+# plot
+fig, ax = plt.subplots()
+ax.pie(x, colors=colors, radius=3, center=(4, 4),
+       wedgeprops={"linewidth": 1, "edgecolor": "white"}, frame=True)
+
+ax.set(xlim=(0, 8), xticks=np.arange(1, 8),
+       ylim=(0, 8), yticks=np.arange(1, 8))
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/plot_types/stats/violin.py

@@ -0,0 +1,28 @@
+"""
+=============
+violinplot(D)
+=============
+
+See `~matplotlib.axes.Axes.violinplot`.
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+plt.style.use('_mpl-gallery')
+
+# make data:
+np.random.seed(10)
+D = np.random.normal((3, 5, 4), (0.75, 1.00, 0.75), (200, 3))
+
+# plot:
+fig, ax = plt.subplots()
+
+vp = ax.violinplot(D, [2, 4, 6], widths=2,
+                   showmeans=False, showmedians=False, showextrema=False)
+# styling:
+for body in vp['bodies']:
+    body.set_alpha(0.9)
+ax.set(xlim=(0, 8), xticks=np.arange(1, 8),
+       ylim=(0, 8), yticks=np.arange(1, 8))
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/users_explain/animations/animations.py

@@ -0,0 +1,247 @@
+"""
+.. redirect-from:: /tutorials/introductory/animation_tutorial
+
+.. _animations:
+
+===========================
+Animations using Matplotlib
+===========================
+
+Based on its plotting functionality, Matplotlib also provides an interface to
+generate animations using the `~matplotlib.animation` module. An
+animation is a sequence of frames where each frame corresponds to a plot on a
+`~matplotlib.figure.Figure`. This tutorial covers a general guideline on
+how to create such animations and the different options available.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.animation as animation
+
+# %%
+# Animation Classes
+# =================
+#
+# The animation process in Matplotlib can be thought of in 2 different ways:
+#
+# - `~matplotlib.animation.FuncAnimation`: Generate data for first
+#   frame and then modify this data for each frame to create an animated plot.
+#
+# - `~matplotlib.animation.ArtistAnimation`: Generate a list (iterable)
+#   of artists that will draw in each frame in the animation.
+#
+# `~matplotlib.animation.FuncAnimation` is more efficient in terms of
+# speed and memory as it draws an artist once and then modifies it. On the
+# other hand `~matplotlib.animation.ArtistAnimation` is flexible as it
+# allows any iterable of artists to be animated in a sequence.
+#
+# ``FuncAnimation``
+# -----------------
+#
+# The `~matplotlib.animation.FuncAnimation` class allows us to create an
+# animation by passing a function that iteratively modifies the data of a plot.
+# This is achieved by using the *setter* methods on various
+# `~matplotlib.artist.Artist` (examples: `~matplotlib.lines.Line2D`,
+# `~matplotlib.collections.PathCollection`, etc.). A usual
+# `~matplotlib.animation.FuncAnimation` object takes a
+# `~matplotlib.figure.Figure` that we want to animate and a function
+# *func* that modifies the data plotted on the figure. It uses the *frames*
+# parameter to determine the length of the animation. The *interval* parameter
+# is used to determine time in milliseconds between drawing of two frames.
+# Animating using `.FuncAnimation` would usually follow the following
+# structure:
+#
+# - Plot the initial figure, including all the required artists. Save all the
+#   artists in variables so that they can be updated later on during the
+#   animation.
+# - Create an animation function that updates the data in each artist to
+#   generate the new frame at each function call.
+# - Create a `.FuncAnimation` object with the `.Figure` and the animation
+#   function, along with the keyword arguments that determine the animation
+#   properties.
+# - Use `.animation.Animation.save` or `.pyplot.show` to save or show the
+#   animation.
+#
+# The update function uses the ``set_*`` function for different artists to
+# modify the data. The following table shows a few plotting methods, the artist
+# types they return and some methods that can be used to update them.
+#
+# ========================================  =============================  ===========================
+# Plotting method                           Artist                         Set method
+# ========================================  =============================  ===========================
+# `.Axes.plot`                              `.lines.Line2D`                `~.lines.Line2D.set_data`
+# `.Axes.scatter`                           `.collections.PathCollection`  `~.collections.\
+#                                                                          PathCollection.set_offsets`
+# `.Axes.imshow`                            `.image.AxesImage`             ``AxesImage.set_data``
+# `.Axes.annotate`                          `.text.Annotation`             `~.text.Annotation.\
+#                                                                          update_positions`
+# `.Axes.barh`                              `.patches.Rectangle`           `~.Rectangle.set_angle`,
+#                                                                          `~.Rectangle.set_bounds`,
+#                                                                          `~.Rectangle.set_height`,
+#                                                                          `~.Rectangle.set_width`,
+#                                                                          `~.Rectangle.set_x`,
+#                                                                          `~.Rectangle.set_y`,
+#                                                                          `~.Rectangle.set_xy`
+# `.Axes.fill`                              `.patches.Polygon`             `~.Polygon.set_xy`
+# `.Axes.add_patch`\(`.patches.Ellipse`\)   `.patches.Ellipse`             `~.Ellipse.set_angle`,
+#                                                                          `~.Ellipse.set_center`,
+#                                                                          `~.Ellipse.set_height`,
+#                                                                          `~.Ellipse.set_width`
+# ========================================  =============================  ===========================
+#
+# Covering the set methods for all types of artists is beyond the scope of this
+# tutorial but can be found in their respective documentations. An example of
+# such update methods in use for `.Axes.scatter` and `.Axes.plot` is as follows.
+
+fig, ax = plt.subplots()
+t = np.linspace(0, 3, 40)
+g = -9.81
+v0 = 12
+z = g * t**2 / 2 + v0 * t
+
+v02 = 5
+z2 = g * t**2 / 2 + v02 * t
+
+scat = ax.scatter(t[0], z[0], c="b", s=5, label=f'v0 = {v0} m/s')
+line2 = ax.plot(t[0], z2[0], label=f'v0 = {v02} m/s')[0]
+ax.set(xlim=[0, 3], ylim=[-4, 10], xlabel='Time [s]', ylabel='Z [m]')
+ax.legend()
+
+
+def update(frame):
+    # for each frame, update the data stored on each artist.
+    x = t[:frame]
+    y = z[:frame]
+    # update the scatter plot:
+    data = np.stack([x, y]).T
+    scat.set_offsets(data)
+    # update the line plot:
+    line2.set_xdata(t[:frame])
+    line2.set_ydata(z2[:frame])
+    return (scat, line2)
+
+
+ani = animation.FuncAnimation(fig=fig, func=update, frames=40, interval=30)
+plt.show()
+
+
+# %%
+# ``ArtistAnimation``
+# -------------------
+#
+# `~matplotlib.animation.ArtistAnimation` can be used
+# to generate animations if there is data stored on various different artists.
+# This list of artists is then converted frame by frame into an animation. For
+# example, when we use `.Axes.barh` to plot a bar-chart, it creates a number of
+# artists for each of the bar and error bars. To update the plot, one would
+# need to update each of the bars from the container individually and redraw
+# them. Instead, `.animation.ArtistAnimation` can be used to plot each frame
+# individually and then stitched together to form an animation. A barchart race
+# is a simple example for this.
+
+
+fig, ax = plt.subplots()
+rng = np.random.default_rng(19680801)
+data = np.array([20, 20, 20, 20])
+x = np.array([1, 2, 3, 4])
+
+artists = []
+colors = ['tab:blue', 'tab:red', 'tab:green', 'tab:purple']
+for i in range(20):
+    data += rng.integers(low=0, high=10, size=data.shape)
+    container = ax.barh(x, data, color=colors)
+    artists.append(container)
+
+
+ani = animation.ArtistAnimation(fig=fig, artists=artists, interval=400)
+plt.show()
+
+# %%
+# Animation Writers
+# =================
+#
+# Animation objects can be saved to disk using various multimedia writers
+# (ex: Pillow, *ffpmeg*, *imagemagick*). Not all video formats are supported
+# by all writers. There are 4 major types of writers:
+#
+# - `~matplotlib.animation.PillowWriter` - Uses the Pillow library to
+#   create the animation.
+#
+# - `~matplotlib.animation.HTMLWriter` - Used to create JavaScript-based
+#   animations.
+#
+# - Pipe-based writers - `~matplotlib.animation.FFMpegWriter` and
+#   `~matplotlib.animation.ImageMagickWriter` are pipe based writers.
+#   These writers pipe each frame to the utility (*ffmpeg* / *imagemagick*)
+#   which then stitches all of them together to create the animation.
+#
+# - File-based writers - `~matplotlib.animation.FFMpegFileWriter` and
+#   `~matplotlib.animation.ImageMagickFileWriter` are examples of
+#   file-based writers. These writers are slower than their pipe-based
+#   alternatives but are more useful for debugging as they save each frame in
+#   a file before stitching them together into an animation.
+#
+# Saving Animations
+# -----------------
+#
+# .. list-table::
+#    :header-rows: 1
+#
+#    * - Writer
+#      - Supported Formats
+#    * - `~matplotlib.animation.PillowWriter`
+#      - .gif, .apng, .webp
+#    * - `~matplotlib.animation.HTMLWriter`
+#      - .htm, .html, .png
+#    * - | `~matplotlib.animation.FFMpegWriter`
+#        | `~matplotlib.animation.FFMpegFileWriter`
+#      - All formats supported by |ffmpeg|_: ``ffmpeg -formats``
+#    * - | `~matplotlib.animation.ImageMagickWriter`
+#        | `~matplotlib.animation.ImageMagickFileWriter`
+#      - All formats supported by |imagemagick|_: ``magick -list format``
+#
+# .. _ffmpeg: https://www.ffmpeg.org/general.html#Supported-File-Formats_002c-Codecs-or-Features
+# .. |ffmpeg| replace:: *ffmpeg*
+#
+# .. _imagemagick: https://imagemagick.org/script/formats.php#supported
+# .. |imagemagick| replace:: *imagemagick*
+#
+# To save animations using any of the writers, we can use the
+# `.animation.Animation.save` method. It takes the *filename* that we want to
+# save the animation as and the *writer*, which is either a string or a writer
+# object. It also takes an *fps* argument. This argument is different than the
+# *interval* argument that `~.animation.FuncAnimation` or
+# `~.animation.ArtistAnimation` uses. *fps* determines the frame rate that the
+# **saved** animation uses, whereas *interval* determines the frame rate that
+# the **displayed** animation uses.
+#
+# Below are a few examples that show how to save an animation with different
+# writers.
+#
+#
+# Pillow writers::
+#
+#   ani.save(filename="/tmp/pillow_example.gif", writer="pillow")
+#   ani.save(filename="/tmp/pillow_example.apng", writer="pillow")
+#
+# HTML writers::
+#
+#   ani.save(filename="/tmp/html_example.html", writer="html")
+#   ani.save(filename="/tmp/html_example.htm", writer="html")
+#   ani.save(filename="/tmp/html_example.png", writer="html")
+#
+# FFMpegWriter::
+#
+#   ani.save(filename="/tmp/ffmpeg_example.mkv", writer="ffmpeg")
+#   ani.save(filename="/tmp/ffmpeg_example.mp4", writer="ffmpeg")
+#   ani.save(filename="/tmp/ffmpeg_example.mjpeg", writer="ffmpeg")
+#
+# Imagemagick writers::
+#
+#   ani.save(filename="/tmp/imagemagick_example.gif", writer="imagemagick")
+#   ani.save(filename="/tmp/imagemagick_example.webp", writer="imagemagick")
+#   ani.save(filename="apng:/tmp/imagemagick_example.apng",
+#            writer="imagemagick", extra_args=["-quality", "100"])
+#
+# (the ``extra_args`` for *apng* are needed to reduce filesize by ~10x)

testbed/matplotlib__matplotlib/galleries/users_explain/animations/blitting.py

@@ -0,0 +1,232 @@
+"""
+.. redirect-from:: /tutorials/advanced/blitting
+
+.. _blitting:
+
+==================================
+Faster rendering by using blitting
+==================================
+
+*Blitting* is a `standard technique
+<https://en.wikipedia.org/wiki/Bit_blit>`__ in raster graphics that,
+in the context of Matplotlib, can be used to (drastically) improve
+performance of interactive figures. For example, the
+:mod:`.animation` and :mod:`.widgets` modules use blitting
+internally. Here, we demonstrate how to implement your own blitting, outside
+of these classes.
+
+Blitting speeds up repetitive drawing by rendering all non-changing
+graphic elements into a background image once. Then, for every draw, only the
+changing elements need to be drawn onto this background. For example,
+if the limits of an Axes have not changed, we can render the empty Axes
+including all ticks and labels once, and only draw the changing data later.
+
+The strategy is
+
+- Prepare the constant background:
+
+  - Draw the figure, but exclude all artists that you want to animate by
+    marking them as *animated* (see `.Artist.set_animated`).
+  - Save a copy of the RBGA buffer.
+
+- Render the individual images:
+
+  - Restore the copy of the RGBA buffer.
+  - Redraw the animated artists using `.Axes.draw_artist` /
+    `.Figure.draw_artist`.
+  - Show the resulting image on the screen.
+
+One consequence of this procedure is that your animated artists are always
+drawn on top of the static artists.
+
+Not all backends support blitting.  You can check if a given canvas does via
+the `.FigureCanvasBase.supports_blit` property.
+
+.. warning::
+
+   This code does not work with the OSX backend (but does work with other
+   GUI backends on Mac).
+
+Minimal example
+---------------
+
+We can use the `.FigureCanvasAgg` methods
+`~.FigureCanvasAgg.copy_from_bbox` and
+`~.FigureCanvasAgg.restore_region` in conjunction with setting
+``animated=True`` on our artist to implement a minimal example that
+uses blitting to accelerate rendering
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.linspace(0, 2 * np.pi, 100)
+
+fig, ax = plt.subplots()
+
+# animated=True tells matplotlib to only draw the artist when we
+# explicitly request it
+(ln,) = ax.plot(x, np.sin(x), animated=True)
+
+# make sure the window is raised, but the script keeps going
+plt.show(block=False)
+
+# stop to admire our empty window axes and ensure it is rendered at
+# least once.
+#
+# We need to fully draw the figure at its final size on the screen
+# before we continue on so that :
+#  a) we have the correctly sized and drawn background to grab
+#  b) we have a cached renderer so that ``ax.draw_artist`` works
+# so we spin the event loop to let the backend process any pending operations
+plt.pause(0.1)
+
+# get copy of entire figure (everything inside fig.bbox) sans animated artist
+bg = fig.canvas.copy_from_bbox(fig.bbox)
+# draw the animated artist, this uses a cached renderer
+ax.draw_artist(ln)
+# show the result to the screen, this pushes the updated RGBA buffer from the
+# renderer to the GUI framework so you can see it
+fig.canvas.blit(fig.bbox)
+
+for j in range(100):
+    # reset the background back in the canvas state, screen unchanged
+    fig.canvas.restore_region(bg)
+    # update the artist, neither the canvas state nor the screen have changed
+    ln.set_ydata(np.sin(x + (j / 100) * np.pi))
+    # re-render the artist, updating the canvas state, but not the screen
+    ax.draw_artist(ln)
+    # copy the image to the GUI state, but screen might not be changed yet
+    fig.canvas.blit(fig.bbox)
+    # flush any pending GUI events, re-painting the screen if needed
+    fig.canvas.flush_events()
+    # you can put a pause in if you want to slow things down
+    # plt.pause(.1)
+
+# %%
+# This example works and shows a simple animation, however because we
+# are only grabbing the background once, if the size of the figure in
+# pixels changes (due to either the size or dpi of the figure
+# changing) , the background will be invalid and result in incorrect
+# (but sometimes cool looking!) images.  There is also a global
+# variable and a fair amount of boilerplate which suggests we should
+# wrap this in a class.
+#
+# Class-based example
+# -------------------
+#
+# We can use a class to encapsulate the boilerplate logic and state of
+# restoring the background, drawing the artists, and then blitting the
+# result to the screen.  Additionally, we can use the ``'draw_event'``
+# callback to capture a new background whenever a full re-draw
+# happens to handle resizes correctly.
+
+
+class BlitManager:
+    def __init__(self, canvas, animated_artists=()):
+        """
+        Parameters
+        ----------
+        canvas : FigureCanvasAgg
+            The canvas to work with, this only works for subclasses of the Agg
+            canvas which have the `~FigureCanvasAgg.copy_from_bbox` and
+            `~FigureCanvasAgg.restore_region` methods.
+
+        animated_artists : Iterable[Artist]
+            List of the artists to manage
+        """
+        self.canvas = canvas
+        self._bg = None
+        self._artists = []
+
+        for a in animated_artists:
+            self.add_artist(a)
+        # grab the background on every draw
+        self.cid = canvas.mpl_connect("draw_event", self.on_draw)
+
+    def on_draw(self, event):
+        """Callback to register with 'draw_event'."""
+        cv = self.canvas
+        if event is not None:
+            if event.canvas != cv:
+                raise RuntimeError
+        self._bg = cv.copy_from_bbox(cv.figure.bbox)
+        self._draw_animated()
+
+    def add_artist(self, art):
+        """
+        Add an artist to be managed.
+
+        Parameters
+        ----------
+        art : Artist
+
+            The artist to be added.  Will be set to 'animated' (just
+            to be safe).  *art* must be in the figure associated with
+            the canvas this class is managing.
+
+        """
+        if art.figure != self.canvas.figure:
+            raise RuntimeError
+        art.set_animated(True)
+        self._artists.append(art)
+
+    def _draw_animated(self):
+        """Draw all of the animated artists."""
+        fig = self.canvas.figure
+        for a in self._artists:
+            fig.draw_artist(a)
+
+    def update(self):
+        """Update the screen with animated artists."""
+        cv = self.canvas
+        fig = cv.figure
+        # paranoia in case we missed the draw event,
+        if self._bg is None:
+            self.on_draw(None)
+        else:
+            # restore the background
+            cv.restore_region(self._bg)
+            # draw all of the animated artists
+            self._draw_animated()
+            # update the GUI state
+            cv.blit(fig.bbox)
+        # let the GUI event loop process anything it has to do
+        cv.flush_events()
+
+
+# %%
+# Here is how we would use our class.  This is a slightly more complicated
+# example than the first case as we add a text frame counter as well.
+
+# make a new figure
+fig, ax = plt.subplots()
+# add a line
+(ln,) = ax.plot(x, np.sin(x), animated=True)
+# add a frame number
+fr_number = ax.annotate(
+    "0",
+    (0, 1),
+    xycoords="axes fraction",
+    xytext=(10, -10),
+    textcoords="offset points",
+    ha="left",
+    va="top",
+    animated=True,
+)
+bm = BlitManager(fig.canvas, [ln, fr_number])
+# make sure our window is on the screen and drawn
+plt.show(block=False)
+plt.pause(.1)
+
+for j in range(100):
+    # update the artists
+    ln.set_ydata(np.sin(x + (j / 100) * np.pi))
+    fr_number.set_text(f"frame: {j}")
+    # tell the blitting manager to do its thing
+    bm.update()
+
+# %%
+# This class does not depend on `.pyplot` and is suitable to embed
+# into larger GUI application.

testbed/matplotlib__matplotlib/galleries/users_explain/artists/artist_intro.rst

@@ -0,0 +1,186 @@
+.. _users_artists:
+
+Introduction to Artists
+-----------------------
+
+Almost all objects you interact with on a Matplotlib plot are called "Artist"
+(and are subclasses of the `.Artist` class).  :doc:`Figure <../figure/index>`
+and :doc:`Axes <../axes/index>` are Artists, and generally contain
+`~.axis.Axis` Artists and Artists that contain data or annotation information.
+
+
+Creating Artists
+~~~~~~~~~~~~~~~~
+
+Usually we do not instantiate Artists directly, but rather use a plotting
+method on `~.axes.Axes`.  Some examples of plotting methods and the Artist
+object they create is given below:
+
+=========================================  =================
+Axes helper method                         Artist
+=========================================  =================
+`~.axes.Axes.annotate` - text annotations  `.Annotation`
+`~.axes.Axes.bar` - bar charts             `.Rectangle`
+`~.axes.Axes.errorbar` - error bar plots   `.Line2D` and
+                                           `.Rectangle`
+`~.axes.Axes.fill` - shared area           `.Polygon`
+`~.axes.Axes.hist` - histograms            `.Rectangle`
+`~.axes.Axes.imshow` - image data          `.AxesImage`
+`~.axes.Axes.legend` - Axes legend         `.Legend`
+`~.axes.Axes.plot` - xy plots              `.Line2D`
+`~.axes.Axes.scatter` - scatter charts     `.PolyCollection`
+`~.axes.Axes.text` - text                  `.Text`
+=========================================  =================
+
+As an example, we can save the Line2D Artist returned from `.axes.Axes.plot`:
+
+.. sourcecode:: ipython
+
+    In [209]: import matplotlib.pyplot as plt
+    In [210]: import matplotlib.artist as martist
+    In [211]: import numpy as np
+
+    In [212]: fig, ax = plt.subplots()
+    In [213]: x, y = np.random.rand(2, 100)
+    In [214]: lines = ax.plot(x, y, '-', label='example')
+    In [215]: print(lines)
+    [<matplotlib.lines.Line2D at 0xd378b0c>]
+
+Note that ``plot`` returns a _list_ of lines because you can pass in multiple x,
+y pairs to plot.  The line has been added to the Axes, and we can retrieve the
+Artist via `~.Axes.get_lines()`:
+
+.. sourcecode:: ipython
+
+    In [216]: print(ax.get_lines())
+    <a list of 1 Line2D objects>
+    In [217]: print(ax.get_lines()[0])
+    Line2D(example)
+
+Changing Artist properties
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Getting the ``lines`` object gives us access to all the properties of the
+Line2D object.  So if we want to change the *linewidth* after the fact, we can do so using `.Artist.set`.
+
+.. plot::
+    :include-source:
+
+    fig, ax = plt.subplots(figsize=(4, 2.5))
+    x = np.arange(0, 13, 0.2)
+    y = np.sin(x)
+    lines = ax.plot(x, y, '-', label='example', linewidth=0.2, color='blue')
+    lines[0].set(color='green', linewidth=2)
+
+We can interrogate the full list of settable properties with
+`matplotlib.artist.getp`:
+
+.. sourcecode:: ipython
+
+    In [218]: martist.getp(lines[0])
+    agg_filter = None
+    alpha = None
+    animated = False
+    antialiased or aa = True
+    bbox = Bbox(x0=0.004013842290585101, y0=0.013914221641967...
+    children = []
+    clip_box = TransformedBbox(     Bbox(x0=0.0, y0=0.0, x1=1.0, ...
+    clip_on = True
+    clip_path = None
+    color or c = blue
+    dash_capstyle = butt
+    dash_joinstyle = round
+    data = (array([0.91377845, 0.58456834, 0.36492019, 0.0379...
+    drawstyle or ds = default
+    figure = Figure(550x450)
+    fillstyle = full
+    gapcolor = None
+    gid = None
+    in_layout = True
+    label = example
+    linestyle or ls = -
+    linewidth or lw = 2.0
+    marker = None
+    markeredgecolor or mec = blue
+    markeredgewidth or mew = 1.0
+    markerfacecolor or mfc = blue
+    markerfacecoloralt or mfcalt = none
+    markersize or ms = 6.0
+    markevery = None
+    mouseover = False
+    path = Path(array([[0.91377845, 0.51224793],        [0.58...
+    path_effects = []
+    picker = None
+    pickradius = 5
+    rasterized = False
+    sketch_params = None
+    snap = None
+    solid_capstyle = projecting
+    solid_joinstyle = round
+    tightbbox = Bbox(x0=70.4609002763619, y0=54.321277798941786, x...
+    transform = CompositeGenericTransform(     TransformWrapper(  ...
+    transformed_clip_path_and_affine = (None, None)
+    url = None
+    visible = True
+    window_extent = Bbox(x0=70.4609002763619, y0=54.321277798941786, x...
+    xdata = [0.91377845 0.58456834 0.36492019 0.03796664 0.884...
+    xydata = [[0.91377845 0.51224793]  [0.58456834 0.9820474 ] ...
+    ydata = [0.51224793 0.9820474  0.24469912 0.61647032 0.483...
+    zorder = 2
+
+Note most Artists also have a distinct list of setters; e.g.
+`.Line2D.set_color` or `.Line2D.set_linewidth`.
+
+Changing Artist data
+~~~~~~~~~~~~~~~~~~~~
+
+In addition to styling properties like *color* and *linewidth*, the Line2D
+object has a *data* property.  You can set the data after the line has been
+created using `.Line2D.set_data`.  This is often used for Animations, where the
+same line is shown evolving over time (see :doc:`../animations/index`)
+
+.. plot::
+    :include-source:
+
+    fig, ax = plt.subplots(figsize=(4, 2.5))
+    x = np.arange(0, 13, 0.2)
+    y = np.sin(x)
+    lines = ax.plot(x, y, '-', label='example')
+    lines[0].set_data([x, np.cos(x)])
+
+Manually adding Artists
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Not all Artists have helper methods, or you may want to use a low-level method
+for some reason.  For example the `.patches.Circle` Artist does not have a
+helper, but we can still create and add to an Axes using the
+`.axes.Axes.add_artist` method:
+
+.. plot::
+    :include-source:
+
+    import matplotlib.patches as mpatches
+
+    fig, ax = plt.subplots(figsize=(4, 2.5))
+    circle = mpatches.Circle((0.5, 0.5), 0.25, ec="none")
+    ax.add_artist(circle)
+    clipped_circle = mpatches.Circle((1, 0.5), 0.125, ec="none", facecolor='C1')
+    ax.add_artist(clipped_circle)
+    ax.set_aspect(1)
+
+The Circle takes the center and radius of the Circle as arguments to its
+constructor; optional arguments are passed as keyword arguments.
+
+Note that when we add an Artist manually like this, it doesn't necessarily
+adjust the axis limits like most of the helper methods do, so the Artists can
+be clipped, as is the case above for the ``clipped_circle`` patch.
+
+See :ref:`artist_reference` for other patches.
+
+Removing Artists
+~~~~~~~~~~~~~~~~
+
+Sometimes we want to remove an Artist from a figure without re-specifying the
+whole figure from scratch.  Most Artists have a usable *remove* method that
+will remove the Artist from its Axes list. For instance ``lines[0].remove()``
+would remove the *Line2D* artist created in the example above.

testbed/matplotlib__matplotlib/galleries/users_explain/artists/imshow_extent.py

@@ -0,0 +1,266 @@
+"""
+.. redirect-from:: /tutorials/intermediate/imshow_extent
+
+.. _imshow_extent:
+
+*origin* and *extent* in `~.Axes.imshow`
+========================================
+
+:meth:`~.Axes.imshow` allows you to render an image (either a 2D array which
+will be color-mapped (based on *norm* and *cmap*) or a 3D RGB(A) array which
+will be used as-is) to a rectangular region in data space.  The orientation of
+the image in the final rendering is controlled by the *origin* and *extent*
+keyword arguments (and attributes on the resulting `.AxesImage` instance) and
+the data limits of the axes.
+
+The *extent* keyword arguments controls the bounding box in data coordinates
+that the image will fill specified as ``(left, right, bottom, top)`` in **data
+coordinates**, the *origin* keyword argument controls how the image fills that
+bounding box, and the orientation in the final rendered image is also affected
+by the axes limits.
+
+.. hint:: Most of the code below is used for adding labels and informative
+   text to the plots. The described effects of *origin* and *extent* can be
+   seen in the plots without the need to follow all code details.
+
+   For a quick understanding, you may want to skip the code details below and
+   directly continue with the discussion of the results.
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+from matplotlib.gridspec import GridSpec
+
+
+def index_to_coordinate(index, extent, origin):
+    """Return the pixel center of an index."""
+    left, right, bottom, top = extent
+
+    hshift = 0.5 * np.sign(right - left)
+    left, right = left + hshift, right - hshift
+    vshift = 0.5 * np.sign(top - bottom)
+    bottom, top = bottom + vshift, top - vshift
+
+    if origin == 'upper':
+        bottom, top = top, bottom
+
+    return {
+        "[0, 0]": (left, bottom),
+        "[M', 0]": (left, top),
+        "[0, N']": (right, bottom),
+        "[M', N']": (right, top),
+    }[index]
+
+
+def get_index_label_pos(index, extent, origin, inverted_xindex):
+    """
+    Return the desired position and horizontal alignment of an index label.
+    """
+    if extent is None:
+        extent = lookup_extent(origin)
+    left, right, bottom, top = extent
+    x, y = index_to_coordinate(index, extent, origin)
+
+    is_x0 = index[-2:] == "0]"
+    halign = 'left' if is_x0 ^ inverted_xindex else 'right'
+    hshift = 0.5 * np.sign(left - right)
+    x += hshift * (1 if is_x0 else -1)
+    return x, y, halign
+
+
+def get_color(index, data, cmap):
+    """Return the data color of an index."""
+    val = {
+        "[0, 0]": data[0, 0],
+        "[0, N']": data[0, -1],
+        "[M', 0]": data[-1, 0],
+        "[M', N']": data[-1, -1],
+    }[index]
+    return cmap(val / data.max())
+
+
+def lookup_extent(origin):
+    """Return extent for label positioning when not given explicitly."""
+    if origin == 'lower':
+        return (-0.5, 6.5, -0.5, 5.5)
+    else:
+        return (-0.5, 6.5, 5.5, -0.5)
+
+
+def set_extent_None_text(ax):
+    ax.text(3, 2.5, 'equals\nextent=None', size='large',
+            ha='center', va='center', color='w')
+
+
+def plot_imshow_with_labels(ax, data, extent, origin, xlim, ylim):
+    """Actually run ``imshow()`` and add extent and index labels."""
+    im = ax.imshow(data, origin=origin, extent=extent)
+
+    # extent labels (left, right, bottom, top)
+    left, right, bottom, top = im.get_extent()
+    if xlim is None or top > bottom:
+        upper_string, lower_string = 'top', 'bottom'
+    else:
+        upper_string, lower_string = 'bottom', 'top'
+    if ylim is None or left < right:
+        port_string, starboard_string = 'left', 'right'
+        inverted_xindex = False
+    else:
+        port_string, starboard_string = 'right', 'left'
+        inverted_xindex = True
+    bbox_kwargs = {'fc': 'w', 'alpha': .75, 'boxstyle': "round4"}
+    ann_kwargs = {'xycoords': 'axes fraction',
+                  'textcoords': 'offset points',
+                  'bbox': bbox_kwargs}
+    ax.annotate(upper_string, xy=(.5, 1), xytext=(0, -1),
+                ha='center', va='top', **ann_kwargs)
+    ax.annotate(lower_string, xy=(.5, 0), xytext=(0, 1),
+                ha='center', va='bottom', **ann_kwargs)
+    ax.annotate(port_string, xy=(0, .5), xytext=(1, 0),
+                ha='left', va='center', rotation=90,
+                **ann_kwargs)
+    ax.annotate(starboard_string, xy=(1, .5), xytext=(-1, 0),
+                ha='right', va='center', rotation=-90,
+                **ann_kwargs)
+    ax.set_title(f'origin: {origin}')
+
+    # index labels
+    for index in ["[0, 0]", "[0, N']", "[M', 0]", "[M', N']"]:
+        tx, ty, halign = get_index_label_pos(index, extent, origin,
+                                             inverted_xindex)
+        facecolor = get_color(index, data, im.get_cmap())
+        ax.text(tx, ty, index, color='white', ha=halign, va='center',
+                bbox={'boxstyle': 'square', 'facecolor': facecolor})
+    if xlim:
+        ax.set_xlim(*xlim)
+    if ylim:
+        ax.set_ylim(*ylim)
+
+
+def generate_imshow_demo_grid(extents, xlim=None, ylim=None):
+    N = len(extents)
+    fig = plt.figure(tight_layout=True)
+    fig.set_size_inches(6, N * (11.25) / 5)
+    gs = GridSpec(N, 5, figure=fig)
+
+    columns = {'label': [fig.add_subplot(gs[j, 0]) for j in range(N)],
+               'upper': [fig.add_subplot(gs[j, 1:3]) for j in range(N)],
+               'lower': [fig.add_subplot(gs[j, 3:5]) for j in range(N)]}
+    x, y = np.ogrid[0:6, 0:7]
+    data = x + y
+
+    for origin in ['upper', 'lower']:
+        for ax, extent in zip(columns[origin], extents):
+            plot_imshow_with_labels(ax, data, extent, origin, xlim, ylim)
+
+    columns['label'][0].set_title('extent=')
+    for ax, extent in zip(columns['label'], extents):
+        if extent is None:
+            text = 'None'
+        else:
+            left, right, bottom, top = extent
+            text = (f'left: {left:0.1f}\nright: {right:0.1f}\n'
+                    f'bottom: {bottom:0.1f}\ntop: {top:0.1f}\n')
+        ax.text(1., .5, text, transform=ax.transAxes, ha='right', va='center')
+        ax.axis('off')
+    return columns
+
+
+# %%
+#
+# Default extent
+# --------------
+#
+# First, let's have a look at the default ``extent=None``
+
+generate_imshow_demo_grid(extents=[None])
+
+# %%
+#
+# Generally, for an array of shape (M, N), the first index runs along the
+# vertical, the second index runs along the horizontal.
+# The pixel centers are at integer positions ranging from 0 to ``N' = N - 1``
+# horizontally and from 0 to ``M' = M - 1`` vertically.
+# *origin* determines how the data is filled in the bounding box.
+#
+# For ``origin='lower'``:
+#
+# - [0, 0] is at (left, bottom)
+# - [M', 0] is at (left, top)
+# - [0, N'] is at (right, bottom)
+# - [M', N'] is at (right, top)
+#
+# ``origin='upper'`` reverses the vertical axes direction and filling:
+#
+# - [0, 0] is at (left, top)
+# - [M', 0] is at (left, bottom)
+# - [0, N'] is at (right, top)
+# - [M', N'] is at (right, bottom)
+#
+# In summary, the position of the [0, 0] index as well as the extent are
+# influenced by *origin*:
+#
+# ======  ===============  ==========================================
+# origin  [0, 0] position  extent
+# ======  ===============  ==========================================
+# upper   top left         ``(-0.5, numcols-0.5, numrows-0.5, -0.5)``
+# lower   bottom left      ``(-0.5, numcols-0.5, -0.5, numrows-0.5)``
+# ======  ===============  ==========================================
+#
+# The default value of *origin* is set by :rc:`image.origin` which defaults
+# to ``'upper'`` to match the matrix indexing conventions in math and
+# computer graphics image indexing conventions.
+#
+#
+# Explicit extent
+# ---------------
+#
+# By setting *extent* we define the coordinates of the image area. The
+# underlying image data is interpolated/resampled to fill that area.
+#
+# If the axes is set to autoscale, then the view limits of the axes are set
+# to match the *extent* which ensures that the coordinate set by
+# ``(left, bottom)`` is at the bottom left of the axes!  However, this
+# may invert the axis so they do not increase in the 'natural' direction.
+#
+
+extents = [(-0.5, 6.5, -0.5, 5.5),
+           (-0.5, 6.5, 5.5, -0.5),
+           (6.5, -0.5, -0.5, 5.5),
+           (6.5, -0.5, 5.5, -0.5)]
+
+columns = generate_imshow_demo_grid(extents)
+set_extent_None_text(columns['upper'][1])
+set_extent_None_text(columns['lower'][0])
+
+
+# %%
+#
+# Explicit extent and axes limits
+# -------------------------------
+#
+# If we fix the axes limits by explicitly setting `~.axes.Axes.set_xlim` /
+# `~.axes.Axes.set_ylim`, we force a certain size and orientation of the axes.
+# This can decouple the 'left-right' and 'top-bottom' sense of the image from
+# the orientation on the screen.
+#
+# In the example below we have chosen the limits slightly larger than the
+# extent (note the white areas within the Axes).
+#
+# While we keep the extents as in the examples before, the coordinate (0, 0)
+# is now explicitly put at the bottom left and values increase to up and to
+# the right (from the viewer's point of view).
+# We can see that:
+#
+# - The coordinate ``(left, bottom)`` anchors the image which then fills the
+#   box going towards the ``(right, top)`` point in data space.
+# - The first column is always closest to the 'left'.
+# - *origin* controls if the first row is closest to 'top' or 'bottom'.
+# - The image may be inverted along either direction.
+# - The 'left-right' and 'top-bottom' sense of the image may be uncoupled from
+#   the orientation on the screen.
+
+generate_imshow_demo_grid(extents=[None] + extents,
+                          xlim=(-2, 8), ylim=(-1, 6))
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/users_explain/artists/index.rst

@@ -0,0 +1,23 @@
++++++++
+Artists
++++++++
+
+Almost all objects you interact with on a Matplotlib plot are called "Artist"
+(and are subclasses of the `.Artist` class).  :doc:`Figure <../figure/index>`
+and :doc:`Axes <../axes/index>` are Artists, and generally contain
+`~.axis.Axis` Artists and Artists that contain data or annotation information.
+
+.. toctree::
+    :maxdepth: 2
+
+    artist_intro
+
+.. toctree::
+    :maxdepth: 1
+
+    Automated color cycle <color_cycle>
+    Optimizing Artists for performance <performance>
+    Paths <paths>
+    Path effects guide <patheffects_guide>
+    Understanding the extent keyword argument of imshow <imshow_extent>
+    transforms_tutorial

testbed/matplotlib__matplotlib/galleries/users_explain/artists/paths.py

@@ -0,0 +1,236 @@
+"""
+.. redirect-from:: /tutorials/advanced/path_tutorial
+
+.. _paths:
+
+=============
+Path Tutorial
+=============
+
+Defining paths in your Matplotlib visualization.
+
+The object underlying all of the :mod:`matplotlib.patches` objects is
+the :class:`~matplotlib.path.Path`, which supports the standard set of
+moveto, lineto, curveto commands to draw simple and compound outlines
+consisting of line segments and splines.  The ``Path`` is instantiated
+with a (N, 2) array of (x, y) vertices, and an N-length array of path
+codes.  For example to draw the unit rectangle from (0, 0) to (1, 1), we
+could use this code:
+"""
+
+import matplotlib.pyplot as plt
+
+import matplotlib.patches as patches
+from matplotlib.path import Path
+
+verts = [
+   (0., 0.),  # left, bottom
+   (0., 1.),  # left, top
+   (1., 1.),  # right, top
+   (1., 0.),  # right, bottom
+   (0., 0.),  # ignored
+]
+
+codes = [
+    Path.MOVETO,
+    Path.LINETO,
+    Path.LINETO,
+    Path.LINETO,
+    Path.CLOSEPOLY,
+]
+
+path = Path(verts, codes)
+
+fig, ax = plt.subplots()
+patch = patches.PathPatch(path, facecolor='orange', lw=2)
+ax.add_patch(patch)
+ax.set_xlim(-2, 2)
+ax.set_ylim(-2, 2)
+plt.show()
+
+
+# %%
+# The following path codes are recognized
+#
+# ============= ======================== ======================================
+# Code          Vertices                 Description
+# ============= ======================== ======================================
+# ``STOP``      1 (ignored)              A marker for the end of the entire
+#                                        path (currently not required and
+#                                        ignored).
+# ``MOVETO``    1                        Pick up the pen and move to the given
+#                                        vertex.
+# ``LINETO``    1                        Draw a line from the current position
+#                                        to the given vertex.
+# ``CURVE3``    2:                       Draw a quadratic Bézier curve from the
+#               1 control point,         current position, with the given
+#               1 end point              control point, to the given end point.
+# ``CURVE4``    3:                       Draw a cubic Bézier curve from the
+#               2 control points,        current position, with the given
+#               1 end point              control points, to the given end
+#                                        point.
+# ``CLOSEPOLY`` 1 (the point is ignored) Draw a line segment to the start point
+#                                        of the current polyline.
+# ============= ======================== ======================================
+#
+#
+# .. path-curves:
+#
+#
+# Bézier example
+# ==============
+#
+# Some of the path components require multiple vertices to specify them:
+# for example CURVE 3 is a `Bézier
+# <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`_ curve with one
+# control point and one end point, and CURVE4 has three vertices for the
+# two control points and the end point.  The example below shows a
+# CURVE4 Bézier spline -- the Bézier curve will be contained in the
+# convex hull of the start point, the two control points, and the end
+# point
+
+verts = [
+   (0., 0.),   # P0
+   (0.2, 1.),  # P1
+   (1., 0.8),  # P2
+   (0.8, 0.),  # P3
+]
+
+codes = [
+    Path.MOVETO,
+    Path.CURVE4,
+    Path.CURVE4,
+    Path.CURVE4,
+]
+
+path = Path(verts, codes)
+
+fig, ax = plt.subplots()
+patch = patches.PathPatch(path, facecolor='none', lw=2)
+ax.add_patch(patch)
+
+xs, ys = zip(*verts)
+ax.plot(xs, ys, 'x--', lw=2, color='black', ms=10)
+
+ax.text(-0.05, -0.05, 'P0')
+ax.text(0.15, 1.05, 'P1')
+ax.text(1.05, 0.85, 'P2')
+ax.text(0.85, -0.05, 'P3')
+
+ax.set_xlim(-0.1, 1.1)
+ax.set_ylim(-0.1, 1.1)
+plt.show()
+
+# %%
+# .. compound_paths:
+#
+# Compound paths
+# ==============
+#
+# All of the simple patch primitives in matplotlib, Rectangle, Circle,
+# Polygon, etc, are implemented with simple path.  Plotting functions
+# like :meth:`~matplotlib.axes.Axes.hist` and
+# :meth:`~matplotlib.axes.Axes.bar`, which create a number of
+# primitives, e.g., a bunch of Rectangles, can usually be implemented more
+# efficiently using a compound path.  The reason ``bar`` creates a list
+# of rectangles and not a compound path is largely historical: the
+# :class:`~matplotlib.path.Path` code is comparatively new and ``bar``
+# predates it.  While we could change it now, it would break old code,
+# so here we will cover how to create compound paths, replacing the
+# functionality in bar, in case you need to do so in your own code for
+# efficiency reasons, e.g., you are creating an animated bar plot.
+#
+# We will make the histogram chart by creating a series of rectangles
+# for each histogram bar: the rectangle width is the bin width and the
+# rectangle height is the number of datapoints in that bin.  First we'll
+# create some random normally distributed data and compute the
+# histogram.  Because NumPy returns the bin edges and not centers, the
+# length of ``bins`` is one greater than the length of ``n`` in the
+# example below::
+#
+#     # histogram our data with numpy
+#     data = np.random.randn(1000)
+#     n, bins = np.histogram(data, 100)
+#
+# We'll now extract the corners of the rectangles.  Each of the
+# ``left``, ``bottom``, etc., arrays below is ``len(n)``, where ``n`` is
+# the array of counts for each histogram bar::
+#
+#     # get the corners of the rectangles for the histogram
+#     left = np.array(bins[:-1])
+#     right = np.array(bins[1:])
+#     bottom = np.zeros(len(left))
+#     top = bottom + n
+#
+# Now we have to construct our compound path, which will consist of a
+# series of ``MOVETO``, ``LINETO`` and ``CLOSEPOLY`` for each rectangle.
+# For each rectangle, we need five vertices: one for the ``MOVETO``,
+# three for the ``LINETO``, and one for the ``CLOSEPOLY``.  As indicated
+# in the table above, the vertex for the closepoly is ignored, but we still
+# need it to keep the codes aligned with the vertices::
+#
+#     nverts = nrects*(1+3+1)
+#     verts = np.zeros((nverts, 2))
+#     codes = np.ones(nverts, int) * path.Path.LINETO
+#     codes[0::5] = path.Path.MOVETO
+#     codes[4::5] = path.Path.CLOSEPOLY
+#     verts[0::5, 0] = left
+#     verts[0::5, 1] = bottom
+#     verts[1::5, 0] = left
+#     verts[1::5, 1] = top
+#     verts[2::5, 0] = right
+#     verts[2::5, 1] = top
+#     verts[3::5, 0] = right
+#     verts[3::5, 1] = bottom
+#
+# All that remains is to create the path, attach it to a
+# :class:`~matplotlib.patches.PathPatch`, and add it to our axes::
+#
+#     barpath = path.Path(verts, codes)
+#     patch = patches.PathPatch(barpath, facecolor='green',
+#       edgecolor='yellow', alpha=0.5)
+#     ax.add_patch(patch)
+
+import numpy as np
+
+import matplotlib.patches as patches
+import matplotlib.path as path
+
+fig, ax = plt.subplots()
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+# histogram our data with numpy
+data = np.random.randn(1000)
+n, bins = np.histogram(data, 100)
+
+# get the corners of the rectangles for the histogram
+left = np.array(bins[:-1])
+right = np.array(bins[1:])
+bottom = np.zeros(len(left))
+top = bottom + n
+nrects = len(left)
+
+nverts = nrects*(1+3+1)
+verts = np.zeros((nverts, 2))
+codes = np.ones(nverts, int) * path.Path.LINETO
+codes[0::5] = path.Path.MOVETO
+codes[4::5] = path.Path.CLOSEPOLY
+verts[0::5, 0] = left
+verts[0::5, 1] = bottom
+verts[1::5, 0] = left
+verts[1::5, 1] = top
+verts[2::5, 0] = right
+verts[2::5, 1] = top
+verts[3::5, 0] = right
+verts[3::5, 1] = bottom
+
+barpath = path.Path(verts, codes)
+patch = patches.PathPatch(barpath, facecolor='green',
+                          edgecolor='yellow', alpha=0.5)
+ax.add_patch(patch)
+
+ax.set_xlim(left[0], right[-1])
+ax.set_ylim(bottom.min(), top.max())
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/users_explain/artists/performance.rst

@@ -0,0 +1,148 @@
+.. redirect-from:: /users/explain/performance
+
+.. _performance:
+
+Performance
+===========
+
+Whether exploring data in interactive mode or programmatically
+saving lots of plots, rendering performance can be a challenging
+bottleneck in your pipeline. Matplotlib provides multiple
+ways to greatly reduce rendering time at the cost of a slight
+change (to a settable tolerance) in your plot's appearance.
+The methods available to reduce rendering time depend on the
+type of plot that is being created.
+
+Line segment simplification
+---------------------------
+
+For plots that have line segments (e.g. typical line plots, outlines
+of polygons, etc.), rendering performance can be controlled by
+:rc:`path.simplify` and :rc:`path.simplify_threshold`, which
+can be defined e.g. in the :file:`matplotlibrc` file (see
+:ref:`customizing` for more information about
+the :file:`matplotlibrc` file). :rc:`path.simplify` is a Boolean
+indicating whether or not line segments are simplified at all.
+:rc:`path.simplify_threshold` controls how much line segments are simplified;
+higher thresholds result in quicker rendering.
+
+The following script will first display the data without any
+simplification, and then display the same data with simplification.
+Try interacting with both of them::
+
+  import numpy as np
+  import matplotlib.pyplot as plt
+  import matplotlib as mpl
+
+  # Setup, and create the data to plot
+  y = np.random.rand(100000)
+  y[50000:] *= 2
+  y[np.geomspace(10, 50000, 400).astype(int)] = -1
+  mpl.rcParams['path.simplify'] = True
+
+  mpl.rcParams['path.simplify_threshold'] = 0.0
+  plt.plot(y)
+  plt.show()
+
+  mpl.rcParams['path.simplify_threshold'] = 1.0
+  plt.plot(y)
+  plt.show()
+
+Matplotlib currently defaults to a conservative simplification
+threshold of ``1/9``. To change default settings to use a different
+value, change the :file:`matplotlibrc` file. Alternatively, users
+can create a new style for interactive plotting (with maximal
+simplification) and another style for publication quality plotting
+(with minimal simplification) and activate them as necessary. See
+:ref:`customizing` for instructions on
+how to perform these actions.
+
+The simplification works by iteratively merging line segments
+into a single vector until the next line segment's perpendicular
+distance to the vector (measured in display-coordinate space)
+is greater than the ``path.simplify_threshold`` parameter.
+
+.. note::
+  Changes related to how line segments are simplified were made
+  in version 2.1. Rendering time will still be improved by these
+  parameters prior to 2.1, but rendering time for some kinds of
+  data will be vastly improved in versions 2.1 and greater.
+
+Marker subsampling
+------------------
+
+Markers can also be simplified, albeit less robustly than line
+segments. Marker subsampling is only available to `.Line2D` objects
+(through the ``markevery`` property). Wherever `.Line2D` construction
+parameters are passed through, such as `.pyplot.plot` and `.Axes.plot`,
+the ``markevery`` parameter can be used::
+
+  plt.plot(x, y, markevery=10)
+
+The ``markevery`` argument allows for naive subsampling, or an
+attempt at evenly spaced (along the *x* axis) sampling. See the
+:doc:`/gallery/lines_bars_and_markers/markevery_demo`
+for more information.
+
+Splitting lines into smaller chunks
+-----------------------------------
+
+If you are using the Agg backend (see :ref:`what-is-a-backend`),
+then you can make use of :rc:`agg.path.chunksize`
+This allows users to specify a chunk size, and any lines with
+greater than that many vertices will be split into multiple
+lines, each of which has no more than ``agg.path.chunksize``
+many vertices. (Unless ``agg.path.chunksize`` is zero, in
+which case there is no chunking.) For some kind of data,
+chunking the line up into reasonable sizes can greatly
+decrease rendering time.
+
+The following script will first display the data without any
+chunk size restriction, and then display the same data with
+a chunk size of 10,000. The difference can best be seen when
+the figures are large, try maximizing the GUI and then
+interacting with them::
+
+  import numpy as np
+  import matplotlib.pyplot as plt
+  import matplotlib as mpl
+  mpl.rcParams['path.simplify_threshold'] = 1.0
+
+  # Setup, and create the data to plot
+  y = np.random.rand(100000)
+  y[50000:] *= 2
+  y[np.geomspace(10, 50000, 400).astype(int)] = -1
+  mpl.rcParams['path.simplify'] = True
+
+  mpl.rcParams['agg.path.chunksize'] = 0
+  plt.plot(y)
+  plt.show()
+
+  mpl.rcParams['agg.path.chunksize'] = 10000
+  plt.plot(y)
+  plt.show()
+
+Legends
+-------
+
+The default legend behavior for axes attempts to find the location
+that covers the fewest data points (``loc='best'``). This can be a
+very expensive computation if there are lots of data points. In
+this case, you may want to provide a specific location.
+
+Using the *fast* style
+----------------------
+
+The *fast* style can be used to automatically set
+simplification and chunking parameters to reasonable
+settings to speed up plotting large amounts of data.
+The following code runs it::
+
+  import matplotlib.style as mplstyle
+  mplstyle.use('fast')
+
+It is very lightweight, so it works well with other
+styles. Be sure the fast style is applied last
+so that other styles do not overwrite the settings::
+
+  mplstyle.use(['dark_background', 'ggplot', 'fast'])

testbed/matplotlib__matplotlib/galleries/users_explain/artists/transforms_tutorial.py

@@ -0,0 +1,587 @@
+"""
+.. redirect-from:: /tutorials/advanced/transforms_tutorial
+
+.. _transforms_tutorial:
+
+========================
+Transformations Tutorial
+========================
+
+Like any graphics packages, Matplotlib is built on top of a transformation
+framework to easily move between coordinate systems, the userland *data*
+coordinate system, the *axes* coordinate system, the *figure* coordinate
+system, and the *display* coordinate system.  In 95% of your plotting, you
+won't need to think about this, as it happens under the hood, but as you push
+the limits of custom figure generation, it helps to have an understanding of
+these objects, so you can reuse the existing transformations Matplotlib makes
+available to you, or create your own (see :mod:`matplotlib.transforms`).  The
+table below summarizes some useful coordinate systems, a description of each
+system, and the transformation object for going from each coordinate system to
+the *display* coordinates.  In the "Transformation Object" column, ``ax`` is a
+:class:`~matplotlib.axes.Axes` instance, ``fig`` is a
+:class:`~matplotlib.figure.Figure` instance, and ``subfigure`` is a
+:class:`~matplotlib.figure.SubFigure` instance.
+
+
++----------------+-----------------------------------+---------------------------------------------------+
+|Coordinate      |Description                        |Transformation object                              |
+|system          |                                   |from system to display                             |
++================+===================================+===================================================+
+|"data"          |The coordinate system of the data  |``ax.transData``                                   |
+|                |in the Axes.                       |                                                   |
++----------------+-----------------------------------+---------------------------------------------------+
+|"axes"          |The coordinate system of the       |``ax.transAxes``                                   |
+|                |`~matplotlib.axes.Axes`; (0, 0)    |                                                   |
+|                |is bottom left of the axes, and    |                                                   |
+|                |(1, 1) is top right of the axes.   |                                                   |
++----------------+-----------------------------------+---------------------------------------------------+
+|"subfigure"     |The coordinate system of the       |``subfigure.transSubfigure``                       |
+|                |`.SubFigure`; (0, 0) is bottom left|                                                   |
+|                |of the subfigure, and (1, 1) is top|                                                   |
+|                |right of the subfigure.  If a      |                                                   |
+|                |figure has no subfigures, this is  |                                                   |
+|                |the same as ``transFigure``.       |                                                   |
++----------------+-----------------------------------+---------------------------------------------------+
+|"figure"        |The coordinate system of the       |``fig.transFigure``                                |
+|                |`.Figure`; (0, 0) is bottom left   |                                                   |
+|                |of the figure, and (1, 1) is top   |                                                   |
+|                |right of the figure.               |                                                   |
++----------------+-----------------------------------+---------------------------------------------------+
+|"figure-inches" |The coordinate system of the       |``fig.dpi_scale_trans``                            |
+|                |`.Figure` in inches; (0, 0) is     |                                                   |
+|                |bottom left of the figure, and     |                                                   |
+|                |(width, height) is the top right   |                                                   |
+|                |of the figure in inches.           |                                                   |
++----------------+-----------------------------------+---------------------------------------------------+
+|"xaxis",        |Blended coordinate systems, using  |``ax.get_xaxis_transform()``,                      |
+|"yaxis"         |data coordinates on one direction  |``ax.get_yaxis_transform()``                       |
+|                |and axes coordinates on the other. |                                                   |
++----------------+-----------------------------------+---------------------------------------------------+
+|"display"       |The native coordinate system of the|`None`, or                                         |
+|                |output ; (0, 0) is the bottom left |:class:`~matplotlib.transforms.IdentityTransform()`|
+|                |of the window, and (width, height) |                                                   |
+|                |is top right of the output in      |                                                   |
+|                |"display units".                   |                                                   |
+|                |                                   |                                                   |
+|                |The exact interpretation of the    |                                                   |
+|                |units depends on the back end. For |                                                   |
+|                |example it is pixels for Agg and   |                                                   |
+|                |points for svg/pdf.                |                                                   |
++----------------+-----------------------------------+---------------------------------------------------+
+
+
+
+
+
+The `~matplotlib.transforms.Transform` objects are naive to the source and
+destination coordinate systems, however the objects referred to in the table
+above are constructed to take inputs in their coordinate system, and transform
+the input to the *display* coordinate system.  That is why the *display*
+coordinate system has `None` for the "Transformation Object" column -- it
+already is in *display* coordinates.  The naming and destination conventions
+are an aid to keeping track of the available "standard" coordinate systems and
+transforms.
+
+The transformations also know how to invert themselves (via
+`.Transform.inverted`) to generate a transform from output coordinate system
+back to the input coordinate system.  For example, ``ax.transData`` converts
+values in data coordinates to display coordinates and
+``ax.transData.inversed()`` is a :class:`matplotlib.transforms.Transform` that
+goes from display coordinates to data coordinates. This is particularly useful
+when processing events from the user interface, which typically occur in
+display space, and you want to know where the mouse click or key-press occurred
+in your *data* coordinate system.
+
+Note that specifying the position of Artists in *display* coordinates may
+change their relative location if the ``dpi`` or size of the figure changes.
+This can cause confusion when printing or changing screen resolution, because
+the object can change location and size.  Therefore, it is most common for
+artists placed in an Axes or figure to have their transform set to something
+*other* than the `~.transforms.IdentityTransform()`; the default when an artist
+is added to an Axes using `~.axes.Axes.add_artist` is for the transform to be
+``ax.transData`` so that you can work and think in *data* coordinates and let
+Matplotlib take care of the transformation to *display*.
+
+.. _data-coords:
+
+Data coordinates
+================
+
+Let's start with the most commonly used coordinate, the *data* coordinate
+system.  Whenever you add data to the axes, Matplotlib updates the datalimits,
+most commonly updated with the :meth:`~matplotlib.axes.Axes.set_xlim` and
+:meth:`~matplotlib.axes.Axes.set_ylim` methods.  For example, in the figure
+below, the data limits stretch from 0 to 10 on the x-axis, and -1 to 1 on the
+y-axis.
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.patches as mpatches
+
+x = np.arange(0, 10, 0.005)
+y = np.exp(-x/2.) * np.sin(2*np.pi*x)
+
+fig, ax = plt.subplots()
+ax.plot(x, y)
+ax.set_xlim(0, 10)
+ax.set_ylim(-1, 1)
+
+plt.show()
+
+# %%
+# You can use the ``ax.transData`` instance to transform from your
+# *data* to your *display* coordinate system, either a single point or a
+# sequence of points as shown below:
+#
+# .. sourcecode:: ipython
+#
+#     In [14]: type(ax.transData)
+#     Out[14]: <class 'matplotlib.transforms.CompositeGenericTransform'>
+#
+#     In [15]: ax.transData.transform((5, 0))
+#     Out[15]: array([ 335.175,  247.   ])
+#
+#     In [16]: ax.transData.transform([(5, 0), (1, 2)])
+#     Out[16]:
+#     array([[ 335.175,  247.   ],
+#            [ 132.435,  642.2  ]])
+#
+# You can use the :meth:`~matplotlib.transforms.Transform.inverted`
+# method to create a transform which will take you from *display* to *data*
+# coordinates:
+#
+# .. sourcecode:: ipython
+#
+#     In [41]: inv = ax.transData.inverted()
+#
+#     In [42]: type(inv)
+#     Out[42]: <class 'matplotlib.transforms.CompositeGenericTransform'>
+#
+#     In [43]: inv.transform((335.175,  247.))
+#     Out[43]: array([ 5.,  0.])
+#
+# If your are typing along with this tutorial, the exact values of the
+# *display* coordinates may differ if you have a different window size or
+# dpi setting.  Likewise, in the figure below, the display labeled
+# points are probably not the same as in the ipython session because the
+# documentation figure size defaults are different.
+
+x = np.arange(0, 10, 0.005)
+y = np.exp(-x/2.) * np.sin(2*np.pi*x)
+
+fig, ax = plt.subplots()
+ax.plot(x, y)
+ax.set_xlim(0, 10)
+ax.set_ylim(-1, 1)
+
+xdata, ydata = 5, 0
+# This computing the transform now, if anything
+# (figure size, dpi, axes placement, data limits, scales..)
+# changes re-calling transform will get a different value.
+xdisplay, ydisplay = ax.transData.transform((xdata, ydata))
+
+bbox = dict(boxstyle="round", fc="0.8")
+arrowprops = dict(
+    arrowstyle="->",
+    connectionstyle="angle,angleA=0,angleB=90,rad=10")
+
+offset = 72
+ax.annotate(f'data = ({xdata:.1f}, {ydata:.1f})',
+            (xdata, ydata), xytext=(-2*offset, offset), textcoords='offset points',
+            bbox=bbox, arrowprops=arrowprops)
+
+disp = ax.annotate(f'display = ({xdisplay:.1f}, {ydisplay:.1f})',
+                   (xdisplay, ydisplay), xytext=(0.5*offset, -offset),
+                   xycoords='figure pixels',
+                   textcoords='offset points',
+                   bbox=bbox, arrowprops=arrowprops)
+
+plt.show()
+
+# %%
+# .. warning::
+#
+#   If you run the source code in the example above in a GUI backend,
+#   you may also find that the two arrows for the *data* and *display*
+#   annotations do not point to exactly the same point.  This is because
+#   the display point was computed before the figure was displayed, and
+#   the GUI backend may slightly resize the figure when it is created.
+#   The effect is more pronounced if you resize the figure yourself.
+#   This is one good reason why you rarely want to work in *display*
+#   space, but you can connect to the ``'on_draw'``
+#   :class:`~matplotlib.backend_bases.Event` to update *figure*
+#   coordinates on figure draws; see :ref:`event-handling`.
+#
+# When you change the x or y limits of your axes, the data limits are
+# updated so the transformation yields a new display point.  Note that
+# when we just change the ylim, only the y-display coordinate is
+# altered, and when we change the xlim too, both are altered.  More on
+# this later when we talk about the
+# :class:`~matplotlib.transforms.Bbox`.
+#
+# .. sourcecode:: ipython
+#
+#     In [54]: ax.transData.transform((5, 0))
+#     Out[54]: array([ 335.175,  247.   ])
+#
+#     In [55]: ax.set_ylim(-1, 2)
+#     Out[55]: (-1, 2)
+#
+#     In [56]: ax.transData.transform((5, 0))
+#     Out[56]: array([ 335.175     ,  181.13333333])
+#
+#     In [57]: ax.set_xlim(10, 20)
+#     Out[57]: (10, 20)
+#
+#     In [58]: ax.transData.transform((5, 0))
+#     Out[58]: array([-171.675     ,  181.13333333])
+#
+#
+# .. _axes-coords:
+#
+# Axes coordinates
+# ================
+#
+# After the *data* coordinate system, *axes* is probably the second most
+# useful coordinate system.  Here the point (0, 0) is the bottom left of
+# your axes or subplot, (0.5, 0.5) is the center, and (1.0, 1.0) is the
+# top right.  You can also refer to points outside the range, so (-0.1,
+# 1.1) is to the left and above your axes.  This coordinate system is
+# extremely useful when placing text in your axes, because you often
+# want a text bubble in a fixed, location, e.g., the upper left of the axes
+# pane, and have that location remain fixed when you pan or zoom.  Here
+# is a simple example that creates four panels and labels them 'A', 'B',
+# 'C', 'D' as you often see in journals.
+
+fig = plt.figure()
+for i, label in enumerate(('A', 'B', 'C', 'D')):
+    ax = fig.add_subplot(2, 2, i+1)
+    ax.text(0.05, 0.95, label, transform=ax.transAxes,
+            fontsize=16, fontweight='bold', va='top')
+
+plt.show()
+
+# %%
+# You can also make lines or patches in the *axes* coordinate system, but
+# this is less useful in my experience than using ``ax.transAxes`` for
+# placing text.  Nonetheless, here is a silly example which plots some
+# random dots in data space, and overlays a semi-transparent
+# :class:`~matplotlib.patches.Circle` centered in the middle of the axes
+# with a radius one quarter of the axes -- if your axes does not
+# preserve aspect ratio (see :meth:`~matplotlib.axes.Axes.set_aspect`),
+# this will look like an ellipse.  Use the pan/zoom tool to move around,
+# or manually change the data xlim and ylim, and you will see the data
+# move, but the circle will remain fixed because it is not in *data*
+# coordinates and will always remain at the center of the axes.
+
+fig, ax = plt.subplots()
+x, y = 10*np.random.rand(2, 1000)
+ax.plot(x, y, 'go', alpha=0.2)  # plot some data in data coordinates
+
+circ = mpatches.Circle((0.5, 0.5), 0.25, transform=ax.transAxes,
+                       facecolor='blue', alpha=0.75)
+ax.add_patch(circ)
+plt.show()
+
+# %%
+# .. _blended_transformations:
+#
+# Blended transformations
+# =======================
+#
+# Drawing in *blended* coordinate spaces which mix *axes* with *data*
+# coordinates is extremely useful, for example to create a horizontal
+# span which highlights some region of the y-data but spans across the
+# x-axis regardless of the data limits, pan or zoom level, etc.  In fact
+# these blended lines and spans are so useful, we have built-in
+# functions to make them easy to plot (see
+# :meth:`~matplotlib.axes.Axes.axhline`,
+# :meth:`~matplotlib.axes.Axes.axvline`,
+# :meth:`~matplotlib.axes.Axes.axhspan`,
+# :meth:`~matplotlib.axes.Axes.axvspan`) but for didactic purposes we
+# will implement the horizontal span here using a blended
+# transformation.  This trick only works for separable transformations,
+# like you see in normal Cartesian coordinate systems, but not on
+# inseparable transformations like the
+# :class:`~matplotlib.projections.polar.PolarAxes.PolarTransform`.
+
+import matplotlib.transforms as transforms
+
+fig, ax = plt.subplots()
+x = np.random.randn(1000)
+
+ax.hist(x, 30)
+ax.set_title(r'$\sigma=1 \/ \dots \/ \sigma=2$', fontsize=16)
+
+# the x coords of this transformation are data, and the y coord are axes
+trans = transforms.blended_transform_factory(
+    ax.transData, ax.transAxes)
+# highlight the 1..2 stddev region with a span.
+# We want x to be in data coordinates and y to span from 0..1 in axes coords.
+rect = mpatches.Rectangle((1, 0), width=1, height=1, transform=trans,
+                          color='yellow', alpha=0.5)
+ax.add_patch(rect)
+
+plt.show()
+
+# %%
+# .. note::
+#
+#   The blended transformations where x is in *data* coords and y in *axes*
+#   coordinates is so useful that we have helper methods to return the
+#   versions Matplotlib uses internally for drawing ticks, ticklabels, etc.
+#   The methods are :meth:`matplotlib.axes.Axes.get_xaxis_transform` and
+#   :meth:`matplotlib.axes.Axes.get_yaxis_transform`.  So in the example
+#   above, the call to
+#   :meth:`~matplotlib.transforms.blended_transform_factory` can be
+#   replaced by ``get_xaxis_transform``::
+#
+#     trans = ax.get_xaxis_transform()
+#
+# .. _transforms-fig-scale-dpi:
+#
+# Plotting in physical coordinates
+# ================================
+#
+# Sometimes we want an object to be a certain physical size on the plot.
+# Here we draw the same circle as above, but in physical coordinates.  If done
+# interactively, you can see that changing the size of the figure does
+# not change the offset of the circle from the lower-left corner,
+# does not change its size, and the circle remains a circle regardless of
+# the aspect ratio of the axes.
+
+fig, ax = plt.subplots(figsize=(5, 4))
+x, y = 10*np.random.rand(2, 1000)
+ax.plot(x, y*10., 'go', alpha=0.2)  # plot some data in data coordinates
+# add a circle in fixed-coordinates
+circ = mpatches.Circle((2.5, 2), 1.0, transform=fig.dpi_scale_trans,
+                       facecolor='blue', alpha=0.75)
+ax.add_patch(circ)
+plt.show()
+
+# %%
+# If we change the figure size, the circle does not change its absolute
+# position and is cropped.
+
+fig, ax = plt.subplots(figsize=(7, 2))
+x, y = 10*np.random.rand(2, 1000)
+ax.plot(x, y*10., 'go', alpha=0.2)  # plot some data in data coordinates
+# add a circle in fixed-coordinates
+circ = mpatches.Circle((2.5, 2), 1.0, transform=fig.dpi_scale_trans,
+                       facecolor='blue', alpha=0.75)
+ax.add_patch(circ)
+plt.show()
+
+# %%
+# Another use is putting a patch with a set physical dimension around a
+# data point on the axes.  Here we add together two transforms.  The
+# first sets the scaling of how large the ellipse should be and the second
+# sets its position.  The ellipse is then placed at the origin, and then
+# we use the helper transform :class:`~matplotlib.transforms.ScaledTranslation`
+# to move it
+# to the right place in the ``ax.transData`` coordinate system.
+# This helper is instantiated with::
+#
+#   trans = ScaledTranslation(xt, yt, scale_trans)
+#
+# where *xt* and *yt* are the translation offsets, and *scale_trans* is
+# a transformation which scales *xt* and *yt* at transformation time
+# before applying the offsets.
+#
+# Note the use of the plus operator on the transforms below.
+# This code says: first apply the scale transformation ``fig.dpi_scale_trans``
+# to make the ellipse the proper size, but still centered at (0, 0),
+# and then translate the data to ``xdata[0]`` and ``ydata[0]`` in data space.
+#
+# In interactive use, the ellipse stays the same size even if the
+# axes limits are changed via zoom.
+#
+
+fig, ax = plt.subplots()
+xdata, ydata = (0.2, 0.7), (0.5, 0.5)
+ax.plot(xdata, ydata, "o")
+ax.set_xlim((0, 1))
+
+trans = (fig.dpi_scale_trans +
+         transforms.ScaledTranslation(xdata[0], ydata[0], ax.transData))
+
+# plot an ellipse around the point that is 150 x 130 points in diameter...
+circle = mpatches.Ellipse((0, 0), 150/72, 130/72, angle=40,
+                          fill=None, transform=trans)
+ax.add_patch(circle)
+plt.show()
+
+# %%
+# .. note::
+#
+#   The order of transformation matters.  Here the ellipse
+#   is given the right dimensions in display space *first* and then moved
+#   in data space to the correct spot.
+#   If we had done the ``ScaledTranslation`` first, then
+#   ``xdata[0]`` and ``ydata[0]`` would
+#   first be transformed to *display* coordinates (``[ 358.4  475.2]`` on
+#   a 200-dpi monitor) and then those coordinates
+#   would be scaled by ``fig.dpi_scale_trans`` pushing the center of
+#   the ellipse well off the screen (i.e. ``[ 71680.  95040.]``).
+#
+# .. _offset-transforms-shadow:
+#
+# Using offset transforms to create a shadow effect
+# =================================================
+#
+# Another use of :class:`~matplotlib.transforms.ScaledTranslation` is to create
+# a new transformation that is
+# offset from another transformation, e.g., to place one object shifted a
+# bit relative to another object.  Typically, you want the shift to be in
+# some physical dimension, like points or inches rather than in *data*
+# coordinates, so that the shift effect is constant at different zoom
+# levels and dpi settings.
+#
+# One use for an offset is to create a shadow effect, where you draw one
+# object identical to the first just to the right of it, and just below
+# it, adjusting the zorder to make sure the shadow is drawn first and
+# then the object it is shadowing above it.
+#
+# Here we apply the transforms in the *opposite* order to the use of
+# :class:`~matplotlib.transforms.ScaledTranslation` above. The plot is
+# first made in data coordinates (``ax.transData``) and then shifted by
+# ``dx`` and ``dy`` points using ``fig.dpi_scale_trans``.  (In typography,
+# a `point <https://en.wikipedia.org/wiki/Point_%28typography%29>`_ is
+# 1/72 inches, and by specifying your offsets in points, your figure
+# will look the same regardless of the dpi resolution it is saved in.)
+
+fig, ax = plt.subplots()
+
+# make a simple sine wave
+x = np.arange(0., 2., 0.01)
+y = np.sin(2*np.pi*x)
+line, = ax.plot(x, y, lw=3, color='blue')
+
+# shift the object over 2 points, and down 2 points
+dx, dy = 2/72., -2/72.
+offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
+shadow_transform = ax.transData + offset
+
+# now plot the same data with our offset transform;
+# use the zorder to make sure we are below the line
+ax.plot(x, y, lw=3, color='gray',
+        transform=shadow_transform,
+        zorder=0.5*line.get_zorder())
+
+ax.set_title('creating a shadow effect with an offset transform')
+plt.show()
+
+
+# %%
+# .. note::
+#
+#   The dpi and inches offset is a
+#   common-enough use case that we have a special helper function to
+#   create it in :func:`matplotlib.transforms.offset_copy`, which returns
+#   a new transform with an added offset. So above we could have done::
+#
+#      shadow_transform = transforms.offset_copy(ax.transData,
+#               fig, dx, dy, units='inches')
+#
+#
+# .. _transformation-pipeline:
+#
+# The transformation pipeline
+# ===========================
+#
+# The ``ax.transData`` transform we have been working with in this
+# tutorial is a composite of three different transformations that
+# comprise the transformation pipeline from *data* -> *display*
+# coordinates.  Michael Droettboom implemented the transformations
+# framework, taking care to provide a clean API that segregated the
+# nonlinear projections and scales that happen in polar and logarithmic
+# plots, from the linear affine transformations that happen when you pan
+# and zoom.  There is an efficiency here, because you can pan and zoom
+# in your axes which affects the affine transformation, but you may not
+# need to compute the potentially expensive nonlinear scales or
+# projections on simple navigation events.  It is also possible to
+# multiply affine transformation matrices together, and then apply them
+# to coordinates in one step.  This is not true of all possible
+# transformations.
+#
+#
+# Here is how the ``ax.transData`` instance is defined in the basic
+# separable axis :class:`~matplotlib.axes.Axes` class::
+#
+#   self.transData = self.transScale + (self.transLimits + self.transAxes)
+#
+# We've been introduced to the ``transAxes`` instance above in
+# :ref:`axes-coords`, which maps the (0, 0), (1, 1) corners of the
+# axes or subplot bounding box to *display* space, so let's look at
+# these other two pieces.
+#
+# ``self.transLimits`` is the transformation that takes you from
+# *data* to *axes* coordinates; i.e., it maps your view xlim and ylim
+# to the unit space of the axes (and ``transAxes`` then takes that unit
+# space to display space).  We can see this in action here
+#
+# .. sourcecode:: ipython
+#
+#     In [80]: ax = plt.subplot()
+#
+#     In [81]: ax.set_xlim(0, 10)
+#     Out[81]: (0, 10)
+#
+#     In [82]: ax.set_ylim(-1, 1)
+#     Out[82]: (-1, 1)
+#
+#     In [84]: ax.transLimits.transform((0, -1))
+#     Out[84]: array([ 0.,  0.])
+#
+#     In [85]: ax.transLimits.transform((10, -1))
+#     Out[85]: array([ 1.,  0.])
+#
+#     In [86]: ax.transLimits.transform((10, 1))
+#     Out[86]: array([ 1.,  1.])
+#
+#     In [87]: ax.transLimits.transform((5, 0))
+#     Out[87]: array([ 0.5,  0.5])
+#
+# and we can use this same inverted transformation to go from the unit
+# *axes* coordinates back to *data* coordinates.
+#
+# .. sourcecode:: ipython
+#
+#     In [90]: inv.transform((0.25, 0.25))
+#     Out[90]: array([ 2.5, -0.5])
+#
+# The final piece is the ``self.transScale`` attribute, which is
+# responsible for the optional non-linear scaling of the data, e.g., for
+# logarithmic axes.  When an Axes is initially setup, this is just set to
+# the identity transform, since the basic Matplotlib axes has linear
+# scale, but when you call a logarithmic scaling function like
+# :meth:`~matplotlib.axes.Axes.semilogx` or explicitly set the scale to
+# logarithmic with :meth:`~matplotlib.axes.Axes.set_xscale`, then the
+# ``ax.transScale`` attribute is set to handle the nonlinear projection.
+# The scales transforms are properties of the respective ``xaxis`` and
+# ``yaxis`` :class:`~matplotlib.axis.Axis` instances.  For example, when
+# you call ``ax.set_xscale('log')``, the xaxis updates its scale to a
+# :class:`matplotlib.scale.LogScale` instance.
+#
+# For non-separable axes the PolarAxes, there is one more piece to
+# consider, the projection transformation.  The ``transData``
+# :class:`matplotlib.projections.polar.PolarAxes` is similar to that for
+# the typical separable matplotlib Axes, with one additional piece
+# ``transProjection``::
+#
+#        self.transData = (
+#            self.transScale + self.transShift + self.transProjection +
+#            (self.transProjectionAffine + self.transWedge + self.transAxes))
+#
+# ``transProjection`` handles the projection from the space,
+# e.g., latitude and longitude for map data, or radius and theta for polar
+# data, to a separable Cartesian coordinate system.  There are several
+# projection examples in the :mod:`matplotlib.projections` package, and the
+# best way to learn more is to open the source for those packages and
+# see how to make your own, since Matplotlib supports extensible axes
+# and projections.  Michael Droettboom has provided a nice tutorial
+# example of creating a Hammer projection axes; see
+# :doc:`/gallery/misc/custom_projection`.

testbed/matplotlib__matplotlib/galleries/users_explain/axes/autoscale.py

@@ -0,0 +1,180 @@
+"""
+.. redirect-from:: /tutorials/intermediate/autoscale
+
+.. _autoscale:
+
+Autoscaling
+===========
+
+The limits on an axis can be set manually (e.g. ``ax.set_xlim(xmin, xmax)``)
+or Matplotlib can set them automatically based on the data already on the axes.
+There are a number of options to this autoscaling behaviour, discussed below.
+"""
+
+# %%
+# We will start with a simple line plot showing that autoscaling
+# extends the axis limits 5% beyond the data limits (-2π, 2π).
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib as mpl
+
+x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
+y = np.sinc(x)
+
+fig, ax = plt.subplots()
+ax.plot(x, y)
+
+# %%
+# Margins
+# -------
+# The default margin around the data limits is 5%, which is based on the
+# default configuration setting of :rc:`axes.xmargin`, :rc:`axes.ymargin`,
+# and :rc:`axes.zmargin`:
+
+print(ax.margins())
+
+# %%
+# The margin size can be overridden to make them smaller or larger using
+# `~matplotlib.axes.Axes.margins`:
+
+fig, ax = plt.subplots()
+ax.plot(x, y)
+ax.margins(0.2, 0.2)
+
+# %%
+# In general, margins can be in the range (-0.5, ∞), where negative margins set
+# the axes limits to a subrange of the data range, i.e. they clip data.
+# Using a single number for margins affects both axes, a single margin can be
+# customized using keyword arguments ``x`` or ``y``, but positional and keyword
+# interface cannot be combined.
+
+fig, ax = plt.subplots()
+ax.plot(x, y)
+ax.margins(y=-0.2)
+
+# %%
+# Sticky edges
+# ------------
+# There are plot elements (`.Artist`\s) that are usually used without margins.
+# For example false-color images (e.g. created with `.Axes.imshow`) are not
+# considered in the margins calculation.
+#
+
+xx, yy = np.meshgrid(x, x)
+zz = np.sinc(np.sqrt((xx - 1)**2 + (yy - 1)**2))
+
+fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
+ax[0].imshow(zz)
+ax[0].set_title("default margins")
+ax[1].imshow(zz)
+ax[1].margins(0.2)
+ax[1].set_title("margins(0.2)")
+
+# %%
+# This override of margins is determined by "sticky edges", a
+# property of `.Artist` class that can suppress adding margins to axis
+# limits. The effect of sticky edges can be disabled on an Axes by changing
+# `~matplotlib.axes.Axes.use_sticky_edges`.
+# Artists have a property `.Artist.sticky_edges`, and the values of
+# sticky edges can be changed by writing to ``Artist.sticky_edges.x`` or
+# ``Artist.sticky_edges.y``.
+#
+# The following example shows how overriding works and when it is needed.
+
+fig, ax = plt.subplots(ncols=3, figsize=(16, 10))
+ax[0].imshow(zz)
+ax[0].margins(0.2)
+ax[0].set_title("default use_sticky_edges\nmargins(0.2)")
+ax[1].imshow(zz)
+ax[1].margins(0.2)
+ax[1].use_sticky_edges = False
+ax[1].set_title("use_sticky_edges=False\nmargins(0.2)")
+ax[2].imshow(zz)
+ax[2].margins(-0.2)
+ax[2].set_title("default use_sticky_edges\nmargins(-0.2)")
+
+# %%
+# We can see that setting ``use_sticky_edges`` to *False* renders the image
+# with requested margins.
+#
+# While sticky edges don't increase the axis limits through extra margins,
+# negative margins are still taken into account. This can be seen in
+# the reduced limits of the third image.
+#
+# Controlling autoscale
+# ---------------------
+#
+# By default, the limits are
+# recalculated every time you add a new curve to the plot:
+
+fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
+ax[0].plot(x, y)
+ax[0].set_title("Single curve")
+ax[1].plot(x, y)
+ax[1].plot(x * 2.0, y)
+ax[1].set_title("Two curves")
+
+# %%
+# However, there are cases when you don't want to automatically adjust the
+# viewport to new data.
+#
+# One way to disable autoscaling is to manually set the
+# axis limit. Let's say that we want to see only a part of the data in
+# greater detail. Setting the ``xlim`` persists even if we add more curves to
+# the data. To recalculate the new limits  calling `.Axes.autoscale` will
+# toggle the functionality manually.
+
+fig, ax = plt.subplots(ncols=2, figsize=(12, 8))
+ax[0].plot(x, y)
+ax[0].set_xlim(left=-1, right=1)
+ax[0].plot(x + np.pi * 0.5, y)
+ax[0].set_title("set_xlim(left=-1, right=1)\n")
+ax[1].plot(x, y)
+ax[1].set_xlim(left=-1, right=1)
+ax[1].plot(x + np.pi * 0.5, y)
+ax[1].autoscale()
+ax[1].set_title("set_xlim(left=-1, right=1)\nautoscale()")
+
+# %%
+# We can check that the first plot has autoscale disabled and that the second
+# plot has it enabled again by using `.Axes.get_autoscale_on()`:
+
+print(ax[0].get_autoscale_on())  # False means disabled
+print(ax[1].get_autoscale_on())  # True means enabled -> recalculated
+
+# %%
+# Arguments of the autoscale function give us precise control over the process
+# of autoscaling. A combination of arguments ``enable``, and ``axis`` sets the
+# autoscaling feature for the selected axis (or both). The argument ``tight``
+# sets the margin of the selected axis to zero. To preserve settings of either
+# ``enable`` or ``tight`` you can set the opposite one to *None*, that way
+# it should not be modified. However, setting ``enable`` to *None* and tight
+# to *True* affects both axes regardless of the ``axis`` argument.
+
+fig, ax = plt.subplots()
+ax.plot(x, y)
+ax.margins(0.2, 0.2)
+ax.autoscale(enable=None, axis="x", tight=True)
+
+print(ax.margins())
+
+# %%
+# Working with collections
+# ------------------------
+#
+# Autoscale works out of the box for all lines, patches, and images added to
+# the axes. One of the artists that it won't work with is a `.Collection`.
+# After adding a collection to the axes, one has to manually trigger the
+# `~matplotlib.axes.Axes.autoscale_view()` to recalculate
+# axes limits.
+
+fig, ax = plt.subplots()
+collection = mpl.collections.StarPolygonCollection(
+    5, rotation=0, sizes=(250,),  # five point star, zero angle, size 250px
+    offsets=np.column_stack([x, y]),  # Set the positions
+    offset_transform=ax.transData,  # Propagate transformations of the Axes
+)
+ax.add_collection(collection)
+ax.autoscale_view()

testbed/matplotlib__matplotlib/galleries/users_explain/axes/axes_intro.rst

@@ -0,0 +1,180 @@
+##################################
+Introduction to Axes (or Subplots)
+##################################
+
+
+Matplotlib `~.axes.Axes` are the gateway to creating your data visualizations.
+Once an Axes is placed on a figure there are many methods that can be used to
+add data to the Axes. An Axes typically has a pair of `~.axis.Axis`
+Artists that define the data coordinate system, and include methods to add
+annotations like x- and y-labels, titles, and legends.
+
+.. _anatomy_local:
+
+.. figure:: /_static/anatomy.png
+    :width: 80%
+
+    Anatomy of a Figure
+
+In the picture above, the Axes object was created with ``ax = fig.subplots()``.
+Everything else on the figure was created with methods on this ``ax`` object,
+or can be accessed from it.  If we want to change the label on the x-axis, we
+call ``ax.set_xlabel('New Label')``, if we want to plot some data we call
+``ax.plot(x, y)``.  Indeed, in the figure above, the only Artist that is not
+part of the Axes is the Figure itself, so the `.axes.Axes` class is really the
+gateway to much of Matplotlib's functionality.
+
+Note that Axes are so fundamental to the operation of Matplotlib that a lot of
+material here is duplicate of that in :ref:`quick_start`.
+
+Creating Axes
+-------------
+
+.. plot::
+    :include-source:
+
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    fig, axs = plt.subplots(ncols=2, nrows=2, figsize=(3.5, 2.5),
+                            layout="constrained")
+    # for each Axes, add an artist, in this case a nice label in the middle...
+    for row in range(2):
+        for col in range(2):
+            axs[row, col].annotate(f'axs[{row}, {col}]', (0.5, 0.5),
+                                transform=axs[row, col].transAxes,
+                                ha='center', va='center', fontsize=18,
+                                color='darkgrey')
+    fig.suptitle('plt.subplots()')
+
+
+Axes are added using methods on `~.Figure` objects, or via the `~.pyplot` interface.  These methods are discussed in more detail in :ref:`creating_figures` and :doc:`arranging_axes`. However, for instance `~.Figure.add_axes` will manually position an Axes on the page. In the example above `~.pyplot.subplots` put a grid of subplots on the figure, and ``axs`` is a (2, 2) array of Axes, each of which can have data added to them.
+
+There are a number of other methods for adding Axes to a Figure:
+
+* `.Figure.add_axes`: manually position an Axes. ``fig.add_axes([0, 0, 1,
+  1])`` makes an Axes that fills the whole figure.
+* `.pyplot.subplots` and `.Figure.subplots`: add a grid of Axes as in the example
+  above.  The pyplot version returns both the Figure object and an array of
+  Axes.  Note that ``fig, ax = plt.subplots()`` adds a single Axes to a Figure.
+* `.pyplot.subplot_mosaic` and `.Figure.subplot_mosaic`: add a grid of named
+  Axes and return a dictionary of axes.  For ``fig, axs =
+  plt.subplot_mosaic([['left', 'right'], ['bottom', 'bottom']])``,
+  ``axs['left']`` is an Axes in the top row on the left, and ``axs['bottom']``
+  is an Axes that spans both columns on the bottom.
+
+See :doc:`arranging_axes` for more detail on how to arrange grids of Axes on a
+Figure.
+
+
+Axes plotting methods
+---------------------
+
+Most of the high-level plotting methods are accessed from the `.axes.Axes`
+class.  See the API documentation for a full curated list, and
+:ref:`plot_types` for examples.  A basic example is `.axes.Axes.plot`:
+
+.. plot::
+    :include-source:
+
+    fig, ax = plt.subplots(figsize=(4, 3))
+    np.random.seed(19680801)
+    t = np.arange(100)
+    x = np.cumsum(np.random.randn(100))
+    lines = ax.plot(t, x)
+
+Note that ``plot`` returns a list of *lines* Artists which can subsequently be
+manipulated, as discussed in :ref:`users_artists`.
+
+A very incomplete list of plotting methods is below.  Again, see :ref:`plot_types`
+for more examples, and `.axes.Axes` for the full list of methods.
+
+========================= ==================================================
+:ref:`basic_plots`        `~.axes.Axes.plot`, `~.axes.Axes.scatter`,
+                          `~.axes.Axes.bar`, `~.axes.Axes.step`,
+:ref:`arrays`             `~.axes.Axes.pcolormesh`, `~.axes.Axes.contour`,
+                          `~.axes.Axes.quiver`, `~.axes.Axes.streamplot`,
+                          `~.axes.Axes.imshow`
+:ref:`stats_plots`        `~.axes.Axes.hist`, `~.axes.Axes.errorbar`,
+                          `~.axes.Axes.hist2d`, `~.axes.Axes.pie`,
+                          `~.axes.Axes.boxplot`, `~.axes.Axes.violinplot`
+:ref:`unstructured_plots` `~.axes.Axes.tricontour`, `~.axes.Axes.tripcolor`
+========================= ==================================================
+
+Axes labelling and annotation
+-----------------------------
+
+Usually we want to label the Axes with an xlabel, ylabel, and title, and often we want to have a legend to differentiate plot elements.  The `~.axes.Axes` class has a number of methods to create these annotations.
+
+.. plot::
+    :include-source:
+
+    fig, ax = plt.subplots(figsize=(5, 3), layout='constrained')
+    np.random.seed(19680801)
+    t = np.arange(200)
+    x = np.cumsum(np.random.randn(200))
+    y = np.cumsum(np.random.randn(200))
+    linesx = ax.plot(t, x, label='Random walk x')
+    linesy = ax.plot(t, y, label='Random walk y')
+
+    ax.set_xlabel('Time [s]')
+    ax.set_ylabel('Distance [km]')
+    ax.set_title('Random walk example')
+    ax.legend()
+
+These methods are relatively straight-forward, though there are a number of :ref:`text_props` that can be set on the text objects, like *fontsize*, *fontname*, *horizontalalignment*.  Legends can be much more complicated; see :ref:`legend_guide` for more details.
+
+Note that text can also be added to axes using `~.axes.Axes.text`, and `~.axes.Axes.annotate`.  This can be quite sophisticated: see :ref:`text_props` and :ref:`annotations` for more information.
+
+
+Axes limits, scales, and ticking
+--------------------------------
+
+Each Axes has two (or more) `~.axis.Axis` objects, that can be accessed via :attr:`~matplotlib.axes.Axes.xaxis` and :attr:`~matplotlib.axes.Axes.yaxis` properties.  These have substantial number of methods on them, and for highly customizable Axis-es it is useful to read the API at `~.axis.Axis`.   However, the Axes class offers a number of helpers for the most common of these methods.  Indeed, the `~.axes.Axes.set_xlabel`, discussed above, is a helper for the `~.Axis.set_label_text`.
+
+Other important methods set the extent on the axes (`~.axes.Axes.set_xlim`, `~.axes.Axes.set_ylim`), or more fundamentally the scale of the axes.  So for instance, we can make an Axis have a logarithmic scale, and zoom in on a sub-portion of the data:
+
+.. plot::
+    :include-source:
+
+    fig, ax = plt.subplots(figsize=(4, 2.5), layout='constrained')
+    np.random.seed(19680801)
+    t = np.arange(200)
+    x = 2**np.cumsum(np.random.randn(200))
+    linesx = ax.plot(t, x)
+    ax.set_yscale('log')
+    ax.set_xlim([20, 180])
+
+The Axes class also has helpers to deal with Axis ticks and their labels.  Most straight-forward is `~.axes.Axes.set_xticks` and `~.axes.Axes.set_yticks` which manually set the tick locations and optionally their labels.  Minor ticks can be toggled with `~.axes.Axes.minorticks_on` or `~.axes.Axes.minorticks_off`.
+
+Many aspects of Axes ticks and tick labeling can be adjusted using `~.axes.Axes.tick_params`. For instance, to label the top of the axes instead of the bottom,color the ticks red, and color the ticklabels green:
+
+.. plot::
+    :include-source:
+
+    fig, ax = plt.subplots(figsize=(4, 2.5))
+    ax.plot(np.arange(10))
+    ax.tick_params(top=True, labeltop=True, color='red', axis='x',
+                   labelcolor='green')
+
+
+More fine-grained control on ticks, setting scales, and controlling the Axis can be highly customized beyond these Axes-level helpers.
+
+Axes layout
+-----------
+
+Sometimes it is important to set the aspect ratio of a plot in data space, which we can do with `~.axes.Axes.set_aspect`:
+
+.. plot::
+    :include-source:
+
+    fig, axs = plt.subplots(ncols=2, figsize=(7, 2.5), layout='constrained')
+    np.random.seed(19680801)
+    t = np.arange(200)
+    x = np.cumsum(np.random.randn(200))
+    axs[0].plot(t, x)
+    axs[0].set_title('aspect="auto"')
+
+    axs[1].plot(t, x)
+    axs[1].set_aspect(3)
+    axs[1].set_title('aspect=3')

testbed/matplotlib__matplotlib/galleries/users_explain/axes/axes_ticks.py

@@ -0,0 +1,275 @@
+"""
+.. _user_axes_ticks:
+
+==========
+Axis Ticks
+==========
+
+The x and y Axis on each Axes have default tick "locators" and "formatters"
+that depend on the scale being used (see :ref:`user_axes_scales`).  It is
+possible to customize the ticks and tick labels with either high-level methods
+like `~.axes.Axes.set_xticks` or set the locators and formatters directly on
+the axis.
+
+Manual location and formats
+===========================
+
+The simplest method to customize the tick locations and formats is to use
+`~.axes.Axes.set_xticks` and `~.axes.Axes.set_yticks`.  These can be used on
+either the major or the minor ticks.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+
+import matplotlib.ticker as ticker
+
+
+fig, axs = plt.subplots(2, 1, figsize=(5.4, 5.4), layout='constrained')
+x = np.arange(100)
+for nn, ax in enumerate(axs):
+    ax.plot(x, x)
+    if nn == 1:
+        ax.set_title('Manual ticks')
+        ax.set_yticks(np.arange(0, 100.1, 100/3))
+        xticks = np.arange(0.50, 101, 20)
+        xlabels = [f'\\${x:1.2f}' for x in xticks]
+        ax.set_xticks(xticks, labels=xlabels)
+    else:
+        ax.set_title('Automatic ticks')
+
+# %%
+#
+# Note that the length of the ``labels`` argument must have the same length as
+# the array used to specify the ticks.
+#
+# By default `~.axes.Axes.set_xticks` and `~.axes.Axes.set_yticks` act on the
+# major ticks of an Axis, however it is possible to add minor ticks:
+
+fig, axs = plt.subplots(2, 1, figsize=(5.4, 5.4), layout='constrained')
+x = np.arange(100)
+for nn, ax in enumerate(axs):
+    ax.plot(x, x)
+    if nn == 1:
+        ax.set_title('Manual ticks')
+        ax.set_yticks(np.arange(0, 100.1, 100/3))
+        ax.set_yticks(np.arange(0, 100.1, 100/30), minor=True)
+    else:
+        ax.set_title('Automatic ticks')
+
+
+# %%
+#
+# Locators and Formatters
+# =======================
+#
+# Manually setting the ticks as above works well for specific final plots, but
+# does not adapt as the user interacts with the axes.   At a lower level,
+# Matplotlib has ``Locators`` that are meant to automatically choose ticks
+# depending on the current view limits of the axis, and ``Formatters`` that are
+# meant to format the tick labels automatically.
+#
+# The full list of locators provided by Matplotlib are listed at
+# :ref:`locators`, and the formatters at :ref:`formatters`.
+
+
+# %%
+
+def setup(ax, title):
+    """Set up common parameters for the Axes in the example."""
+    # only show the bottom spine
+    ax.yaxis.set_major_locator(ticker.NullLocator())
+    ax.spines[['left', 'right', 'top']].set_visible(False)
+
+    ax.xaxis.set_ticks_position('bottom')
+    ax.tick_params(which='major', width=1.00, length=5)
+    ax.tick_params(which='minor', width=0.75, length=2.5)
+    ax.set_xlim(0, 5)
+    ax.set_ylim(0, 1)
+    ax.text(0.0, 0.2, title, transform=ax.transAxes,
+            fontsize=14, fontname='Monospace', color='tab:blue')
+
+
+fig, axs = plt.subplots(8, 1, layout='constrained')
+
+# Null Locator
+setup(axs[0], title="NullLocator()")
+axs[0].xaxis.set_major_locator(ticker.NullLocator())
+axs[0].xaxis.set_minor_locator(ticker.NullLocator())
+
+# Multiple Locator
+setup(axs[1], title="MultipleLocator(0.5)")
+axs[1].xaxis.set_major_locator(ticker.MultipleLocator(0.5))
+axs[1].xaxis.set_minor_locator(ticker.MultipleLocator(0.1))
+
+# Fixed Locator
+setup(axs[2], title="FixedLocator([0, 1, 5])")
+axs[2].xaxis.set_major_locator(ticker.FixedLocator([0, 1, 5]))
+axs[2].xaxis.set_minor_locator(ticker.FixedLocator(np.linspace(0.2, 0.8, 4)))
+
+# Linear Locator
+setup(axs[3], title="LinearLocator(numticks=3)")
+axs[3].xaxis.set_major_locator(ticker.LinearLocator(3))
+axs[3].xaxis.set_minor_locator(ticker.LinearLocator(31))
+
+# Index Locator
+setup(axs[4], title="IndexLocator(base=0.5, offset=0.25)")
+axs[4].plot(range(0, 5), [0]*5, color='white')
+axs[4].xaxis.set_major_locator(ticker.IndexLocator(base=0.5, offset=0.25))
+
+# Auto Locator
+setup(axs[5], title="AutoLocator()")
+axs[5].xaxis.set_major_locator(ticker.AutoLocator())
+axs[5].xaxis.set_minor_locator(ticker.AutoMinorLocator())
+
+# MaxN Locator
+setup(axs[6], title="MaxNLocator(n=4)")
+axs[6].xaxis.set_major_locator(ticker.MaxNLocator(4))
+axs[6].xaxis.set_minor_locator(ticker.MaxNLocator(40))
+
+# Log Locator
+setup(axs[7], title="LogLocator(base=10, numticks=15)")
+axs[7].set_xlim(10**3, 10**10)
+axs[7].set_xscale('log')
+axs[7].xaxis.set_major_locator(ticker.LogLocator(base=10, numticks=15))
+plt.show()
+
+# %%
+#
+# Similarly, we can specify "Formatters" for the major and minor ticks on each
+# axis.
+#
+# The tick format is configured via the function `~.Axis.set_major_formatter`
+# or `~.Axis.set_minor_formatter`. It accepts:
+#
+# - a format string, which implicitly creates a `.StrMethodFormatter`.
+# - a function,  implicitly creates a `.FuncFormatter`.
+# - an instance of a `.Formatter` subclass. The most common are
+#
+#   - `.NullFormatter`: No labels on the ticks.
+#   - `.StrMethodFormatter`: Use string `str.format` method.
+#   - `.FormatStrFormatter`: Use %-style formatting.
+#   - `.FuncFormatter`: Define labels through a function.
+#   - `.FixedFormatter`: Set the label strings explicitly.
+#   - `.ScalarFormatter`: Default formatter for scalars: auto-pick the format string.
+#   - `.PercentFormatter`: Format labels as a percentage.
+#
+# See :ref:`formatters` for the complete list.
+
+
+def setup(ax, title):
+    """Set up common parameters for the Axes in the example."""
+    # only show the bottom spine
+    ax.yaxis.set_major_locator(ticker.NullLocator())
+    ax.spines[['left', 'right', 'top']].set_visible(False)
+
+    # define tick positions
+    ax.xaxis.set_major_locator(ticker.MultipleLocator(1.00))
+    ax.xaxis.set_minor_locator(ticker.MultipleLocator(0.25))
+
+    ax.xaxis.set_ticks_position('bottom')
+    ax.tick_params(which='major', width=1.00, length=5)
+    ax.tick_params(which='minor', width=0.75, length=2.5, labelsize=10)
+    ax.set_xlim(0, 5)
+    ax.set_ylim(0, 1)
+    ax.text(0.0, 0.2, title, transform=ax.transAxes,
+            fontsize=14, fontname='Monospace', color='tab:blue')
+
+
+fig = plt.figure(figsize=(8, 8), layout='constrained')
+fig0, fig1, fig2 = fig.subfigures(3, height_ratios=[1.5, 1.5, 7.5])
+
+fig0.suptitle('String Formatting', fontsize=16, x=0, ha='left')
+ax0 = fig0.subplots()
+
+setup(ax0, title="'{x} km'")
+ax0.xaxis.set_major_formatter('{x} km')
+
+fig1.suptitle('Function Formatting', fontsize=16, x=0, ha='left')
+ax1 = fig1.subplots()
+
+setup(ax1, title="def(x, pos): return str(x-5)")
+ax1.xaxis.set_major_formatter(lambda x, pos: str(x-5))
+
+fig2.suptitle('Formatter Object Formatting', fontsize=16, x=0, ha='left')
+axs2 = fig2.subplots(7, 1)
+
+setup(axs2[0], title="NullFormatter()")
+axs2[0].xaxis.set_major_formatter(ticker.NullFormatter())
+
+setup(axs2[1], title="StrMethodFormatter('{x:.3f}')")
+axs2[1].xaxis.set_major_formatter(ticker.StrMethodFormatter("{x:.3f}"))
+
+setup(axs2[2], title="FormatStrFormatter('#%d')")
+axs2[2].xaxis.set_major_formatter(ticker.FormatStrFormatter("#%d"))
+
+
+def fmt_two_digits(x, pos):
+    return f'[{x:.2f}]'
+
+
+setup(axs2[3], title='FuncFormatter("[{:.2f}]".format)')
+axs2[3].xaxis.set_major_formatter(ticker.FuncFormatter(fmt_two_digits))
+
+setup(axs2[4], title="FixedFormatter(['A', 'B', 'C', 'D', 'E', 'F'])")
+# FixedFormatter should only be used together with FixedLocator.
+# Otherwise, one cannot be sure where the labels will end up.
+positions = [0, 1, 2, 3, 4, 5]
+labels = ['A', 'B', 'C', 'D', 'E', 'F']
+axs2[4].xaxis.set_major_locator(ticker.FixedLocator(positions))
+axs2[4].xaxis.set_major_formatter(ticker.FixedFormatter(labels))
+
+setup(axs2[5], title="ScalarFormatter()")
+axs2[5].xaxis.set_major_formatter(ticker.ScalarFormatter(useMathText=True))
+
+setup(axs2[6], title="PercentFormatter(xmax=5)")
+axs2[6].xaxis.set_major_formatter(ticker.PercentFormatter(xmax=5))
+
+
+# %%
+#
+# Styling ticks (tick parameters)
+# ===============================
+#
+# The appearance of ticks can be controlled at a low level by finding the
+# individual `~.axis.Tick` on the axis.  However, usually it is simplest to
+# use `~.axes.Axes.tick_params` to change all the objects at once.
+#
+# The ``tick_params`` method can change the properties of ticks:
+#
+# - length
+# - direction (in or out of the frame)
+# - colors
+# - width and length
+# - and whether the ticks are drawn at the bottom, top, left, or right of the
+#   Axes.
+#
+# It also can control the tick labels:
+#
+# - labelsize (fontsize)
+# - labelcolor (color of the label)
+# - labelrotation
+# - labelbottom, labeltop, labelleft, labelright
+#
+# In addition there is a *pad* keyword argument that specifies how far the tick
+# label is from the tick.
+#
+# Finally, the grid linestyles can be set:
+#
+# - grid_color
+# - grid_alpha
+# - grid_linewidth
+# - grid_linestyle
+#
+# All these properties can be restricted to one axis, and can be applied to
+# just the major or minor ticks
+
+fig, axs = plt.subplots(1, 2, figsize=(6.4, 3.2), layout='constrained')
+
+for nn, ax in enumerate(axs):
+    ax.plot(np.arange(100))
+    if nn == 1:
+        ax.grid('on')
+        ax.tick_params(right=True, left=False, axis='y', color='r', length=16,
+                       grid_color='none')
+        ax.tick_params(axis='x', color='m', length=4, direction='in', width=4,
+                       labelcolor='g', grid_color='b')

testbed/matplotlib__matplotlib/galleries/users_explain/axes/colorbar_placement.py

@@ -0,0 +1,99 @@
+"""
+.. _colorbar_placement:
+
+.. redirect-from:: /gallery/subplots_axes_and_figures/colorbar_placement
+
+=================
+Placing Colorbars
+=================
+
+Colorbars indicate the quantitative extent of image data.  Placing in
+a figure is non-trivial because room needs to be made for them.
+
+The simplest case is just attaching a colorbar to each axes:
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Fixing random state for reproducibility
+np.random.seed(19680801)
+
+fig, axs = plt.subplots(2, 2)
+cmaps = ['RdBu_r', 'viridis']
+for col in range(2):
+    for row in range(2):
+        ax = axs[row, col]
+        pcm = ax.pcolormesh(np.random.random((20, 20)) * (col + 1),
+                            cmap=cmaps[col])
+        fig.colorbar(pcm, ax=ax)
+
+# %%
+# The first column has the same type of data in both rows, so it may
+# be desirable to combine the colorbar which we do by calling
+# `.Figure.colorbar` with a list of axes instead of a single axes.
+
+fig, axs = plt.subplots(2, 2)
+cmaps = ['RdBu_r', 'viridis']
+for col in range(2):
+    for row in range(2):
+        ax = axs[row, col]
+        pcm = ax.pcolormesh(np.random.random((20, 20)) * (col + 1),
+                            cmap=cmaps[col])
+    fig.colorbar(pcm, ax=axs[:, col], shrink=0.6)
+
+# %%
+# Relatively complicated colorbar layouts are possible using this
+# paradigm.  Note that this example works far better with
+# ``layout='constrained'``
+
+fig, axs = plt.subplots(3, 3, layout='constrained')
+for ax in axs.flat:
+    pcm = ax.pcolormesh(np.random.random((20, 20)))
+
+fig.colorbar(pcm, ax=axs[0, :2], shrink=0.6, location='bottom')
+fig.colorbar(pcm, ax=[axs[0, 2]], location='bottom')
+fig.colorbar(pcm, ax=axs[1:, :], location='right', shrink=0.6)
+fig.colorbar(pcm, ax=[axs[2, 1]], location='left')
+
+# %%
+# Colorbars with fixed-aspect-ratio axes
+# ======================================
+#
+# Placing colorbars for axes with a fixed aspect ratio pose a particular
+# challenge as the parent axes changes size depending on the data view.
+
+fig, axs = plt.subplots(2, 2,  layout='constrained')
+cmaps = ['RdBu_r', 'viridis']
+for col in range(2):
+    for row in range(2):
+        ax = axs[row, col]
+        pcm = ax.pcolormesh(np.random.random((20, 20)) * (col + 1),
+                            cmap=cmaps[col])
+        if col == 0:
+            ax.set_aspect(2)
+        else:
+            ax.set_aspect(1/2)
+        if row == 1:
+            fig.colorbar(pcm, ax=ax, shrink=0.6)
+
+# %%
+# One way around this issue is to use an `.Axes.inset_axes` to locate the
+# axes in axes coordinates.  Note that if you zoom in on the axes, and
+# change the shape of the axes, the colorbar will also change position.
+
+fig, axs = plt.subplots(2, 2, layout='constrained')
+cmaps = ['RdBu_r', 'viridis']
+for col in range(2):
+    for row in range(2):
+        ax = axs[row, col]
+        pcm = ax.pcolormesh(np.random.random((20, 20)) * (col + 1),
+                            cmap=cmaps[col])
+        if col == 0:
+            ax.set_aspect(2)
+        else:
+            ax.set_aspect(1/2)
+        if row == 1:
+            cax = ax.inset_axes([1.04, 0.2, 0.05, 0.6])
+            fig.colorbar(pcm, ax=ax, cax=cax)
+
+plt.show()

testbed/matplotlib__matplotlib/galleries/users_explain/axes/constrainedlayout_guide.py

@@ -0,0 +1,734 @@
+"""
+
+.. redirect-from:: /tutorials/intermediate/constrainedlayout_guide
+
+.. _constrainedlayout_guide:
+
+================================
+Constrained Layout Guide
+================================
+
+Use *constrained layout* to fit plots within your figure cleanly.
+
+*Constrained layout* automatically adjusts subplots so that decorations like tick
+labels, legends, and colorbars do not overlap, while still preserving the
+logical layout requested by the user.
+
+*Constrained layout* is similar to :ref:`Tight
+layout<tight_layout_guide>`, but is substantially more
+flexible.  It handles colorbars placed on multiple Axes
+(:ref:`colorbar_placement`) nested layouts (`~.Figure.subfigures`) and Axes that
+span rows or columns (`~.pyplot.subplot_mosaic`), striving to align spines from
+Axes in the same row or column.  In addition, :ref:`Compressed layout
+<compressed_layout>` will try and move fixed aspect-ratio Axes closer together.
+These features are described in this document, as well as some
+:ref:`implementation details <cl_notes_on_algorithm>` discussed at the end.
+
+*Constrained layout* typically needs to be activated before any Axes are added to
+a figure. Two ways of doing so are
+
+* using the respective argument to `~.pyplot.subplots`,
+  `~.pyplot.figure`, `~.pyplot.subplot_mosaic` e.g.::
+
+      plt.subplots(layout="constrained")
+
+* activate it via :ref:`rcParams<customizing-with-dynamic-rc-settings>`, like::
+
+      plt.rcParams['figure.constrained_layout.use'] = True
+
+Those are described in detail throughout the following sections.
+
+.. warning::
+
+    Calling ``plt.tight_layout()`` will turn off *constrained layout*!
+
+Simple example
+==============
+
+In Matplotlib, the location of Axes (including subplots) are specified in
+normalized figure coordinates. It can happen that your axis labels or titles
+(or sometimes even ticklabels) go outside the figure area, and are thus
+clipped.
+"""
+
+# sphinx_gallery_thumbnail_number = 18
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import matplotlib.colors as mcolors
+import matplotlib.gridspec as gridspec
+
+plt.rcParams['savefig.facecolor'] = "0.8"
+plt.rcParams['figure.figsize'] = 4.5, 4.
+plt.rcParams['figure.max_open_warning'] = 50
+
+
+def example_plot(ax, fontsize=12, hide_labels=False):
+    ax.plot([1, 2])
+
+    ax.locator_params(nbins=3)
+    if hide_labels:
+        ax.set_xticklabels([])
+        ax.set_yticklabels([])
+    else:
+        ax.set_xlabel('x-label', fontsize=fontsize)
+        ax.set_ylabel('y-label', fontsize=fontsize)
+        ax.set_title('Title', fontsize=fontsize)
+
+fig, ax = plt.subplots(layout=None)
+example_plot(ax, fontsize=24)
+
+# %%
+# To prevent this, the location of Axes needs to be adjusted. For
+# subplots, this can be done manually by adjusting the subplot parameters
+# using `.Figure.subplots_adjust`. However, specifying your figure with the
+# ``layout="constrained"`` keyword argument will do the adjusting
+# automatically.
+
+fig, ax = plt.subplots(layout="constrained")
+example_plot(ax, fontsize=24)
+
+# %%
+# When you have multiple subplots, often you see labels of different
+# Axes overlapping each other.
+
+fig, axs = plt.subplots(2, 2, layout=None)
+for ax in axs.flat:
+    example_plot(ax)
+
+# %%
+# Specifying ``layout="constrained"`` in the call to ``plt.subplots``
+# causes the layout to be properly constrained.
+
+fig, axs = plt.subplots(2, 2, layout="constrained")
+for ax in axs.flat:
+    example_plot(ax)
+
+# %%
+#
+# Colorbars
+# =========
+#
+# If you create a colorbar with `.Figure.colorbar`, you need to make room for
+# it.  *Constrained layout* does this automatically.  Note that if you
+# specify ``use_gridspec=True`` it will be ignored because this option is made
+# for improving the layout via ``tight_layout``.
+#
+# .. note::
+#
+#   For the `~.axes.Axes.pcolormesh` keyword arguments (``pc_kwargs``) we use a
+#   dictionary to keep the calls consistent across this document.
+
+arr = np.arange(100).reshape((10, 10))
+norm = mcolors.Normalize(vmin=0., vmax=100.)
+# see note above: this makes all pcolormesh calls consistent:
+pc_kwargs = {'rasterized': True, 'cmap': 'viridis', 'norm': norm}
+fig, ax = plt.subplots(figsize=(4, 4), layout="constrained")
+im = ax.pcolormesh(arr, **pc_kwargs)
+fig.colorbar(im, ax=ax, shrink=0.6)
+
+# %%
+# If you specify a list of Axes (or other iterable container) to the
+# ``ax`` argument of ``colorbar``, *constrained layout* will take space from
+# the specified Axes.
+
+fig, axs = plt.subplots(2, 2, figsize=(4, 4), layout="constrained")
+for ax in axs.flat:
+    im = ax.pcolormesh(arr, **pc_kwargs)
+fig.colorbar(im, ax=axs, shrink=0.6)
+
+# %%
+# If you specify a list of Axes from inside a grid of Axes, the colorbar
+# will steal space appropriately, and leave a gap, but all subplots will
+# still be the same size.
+
+fig, axs = plt.subplots(3, 3, figsize=(4, 4), layout="constrained")
+for ax in axs.flat:
+    im = ax.pcolormesh(arr, **pc_kwargs)
+fig.colorbar(im, ax=axs[1:, 1], shrink=0.8)
+fig.colorbar(im, ax=axs[:, -1], shrink=0.6)
+
+# %%
+# Suptitle
+# =========
+#
+# *Constrained layout* can also make room for `~.Figure.suptitle`.
+
+fig, axs = plt.subplots(2, 2, figsize=(4, 4), layout="constrained")
+for ax in axs.flat:
+    im = ax.pcolormesh(arr, **pc_kwargs)
+fig.colorbar(im, ax=axs, shrink=0.6)
+fig.suptitle('Big Suptitle')
+
+# %%
+# Legends
+# =======
+#
+# Legends can be placed outside of their parent axis.
+# *Constrained layout* is designed to handle this for :meth:`.Axes.legend`.
+# However, *constrained layout* does *not* handle legends being created via
+# :meth:`.Figure.legend` (yet).
+
+fig, ax = plt.subplots(layout="constrained")
+ax.plot(np.arange(10), label='This is a plot')
+ax.legend(loc='center left', bbox_to_anchor=(0.8, 0.5))
+
+# %%
+# However, this will steal space from a subplot layout:
+
+fig, axs = plt.subplots(1, 2, figsize=(4, 2), layout="constrained")
+axs[0].plot(np.arange(10))
+axs[1].plot(np.arange(10), label='This is a plot')
+axs[1].legend(loc='center left', bbox_to_anchor=(0.8, 0.5))
+
+# %%
+# In order for a legend or other artist to *not* steal space
+# from the subplot layout, we can ``leg.set_in_layout(False)``.
+# Of course this can mean the legend ends up
+# cropped, but can be useful if the plot is subsequently called
+# with ``fig.savefig('outname.png', bbox_inches='tight')``.  Note,
+# however, that the legend's ``get_in_layout`` status will have to be
+# toggled again to make the saved file work, and we must manually
+# trigger a draw if we want *constrained layout* to adjust the size
+# of the Axes before printing.
+
+fig, axs = plt.subplots(1, 2, figsize=(4, 2), layout="constrained")
+
+axs[0].plot(np.arange(10))
+axs[1].plot(np.arange(10), label='This is a plot')
+leg = axs[1].legend(loc='center left', bbox_to_anchor=(0.8, 0.5))
+leg.set_in_layout(False)
+# trigger a draw so that constrained layout is executed once
+# before we turn it off when printing....
+fig.canvas.draw()
+# we want the legend included in the bbox_inches='tight' calcs.
+leg.set_in_layout(True)
+# we don't want the layout to change at this point.
+fig.set_layout_engine('none')
+try:
+    fig.savefig('../../../doc/_static/constrained_layout_1b.png',
+                bbox_inches='tight', dpi=100)
+except FileNotFoundError:
+    # this allows the script to keep going if run interactively and
+    # the directory above doesn't exist
+    pass
+
+# %%
+# The saved file looks like:
+#
+# .. image:: /_static/constrained_layout_1b.png
+#    :align: center
+#
+# A better way to get around this awkwardness is to simply
+# use the legend method provided by `.Figure.legend`:
+fig, axs = plt.subplots(1, 2, figsize=(4, 2), layout="constrained")
+axs[0].plot(np.arange(10))
+lines = axs[1].plot(np.arange(10), label='This is a plot')
+labels = [l.get_label() for l in lines]
+leg = fig.legend(lines, labels, loc='center left',
+                 bbox_to_anchor=(0.8, 0.5), bbox_transform=axs[1].transAxes)
+try:
+    fig.savefig('../../../doc/_static/constrained_layout_2b.png',
+                bbox_inches='tight', dpi=100)
+except FileNotFoundError:
+    # this allows the script to keep going if run interactively and
+    # the directory above doesn't exist
+    pass
+
+
+# %%
+# The saved file looks like:
+#
+# .. image:: /_static/constrained_layout_2b.png
+#    :align: center
+#
+
+# %%
+# Padding and spacing
+# ===================
+#
+# Padding between Axes is controlled in the horizontal by *w_pad* and
+# *wspace*, and vertical by *h_pad* and *hspace*.  These can be edited
+# via `~.layout_engine.ConstrainedLayoutEngine.set`.  *w/h_pad* are
+# the minimum space around the Axes in units of inches:
+
+fig, axs = plt.subplots(2, 2, layout="constrained")
+for ax in axs.flat:
+    example_plot(ax, hide_labels=True)
+fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72, hspace=0,
+                            wspace=0)
+
+# %%
+# Spacing between subplots is further set by *wspace* and *hspace*. These
+# are specified as a fraction of the size of the subplot group as a whole.
+# If these values are smaller than *w_pad* or *h_pad*, then the fixed pads are
+# used instead. Note in the below how the space at the edges doesn't change
+# from the above, but the space between subplots does.
+
+fig, axs = plt.subplots(2, 2, layout="constrained")
+for ax in axs.flat:
+    example_plot(ax, hide_labels=True)
+fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72, hspace=0.2,
+                            wspace=0.2)
+
+# %%
+# If there are more than two columns, the *wspace* is shared between them,
+# so here the wspace is divided in two, with a *wspace* of 0.1 between each
+# column:
+
+fig, axs = plt.subplots(2, 3, layout="constrained")
+for ax in axs.flat:
+    example_plot(ax, hide_labels=True)
+fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72, hspace=0.2,
+                            wspace=0.2)
+
+# %%
+# GridSpecs also have optional *hspace* and *wspace* keyword arguments,
+# that will be used instead of the pads set by *constrained layout*:
+
+fig, axs = plt.subplots(2, 2, layout="constrained",
+                        gridspec_kw={'wspace': 0.3, 'hspace': 0.2})
+for ax in axs.flat:
+    example_plot(ax, hide_labels=True)
+# this has no effect because the space set in the gridspec trumps the
+# space set in *constrained layout*.
+fig.get_layout_engine().set(w_pad=4 / 72, h_pad=4 / 72, hspace=0.0,
+                            wspace=0.0)
+
+# %%
+# Spacing with colorbars
+# -----------------------
+#
+# Colorbars are placed a distance *pad* from their parent, where *pad*
+# is a fraction of the width of the parent(s).  The spacing to the
+# next subplot is then given by *w/hspace*.
+
+fig, axs = plt.subplots(2, 2, layout="constrained")
+pads = [0, 0.05, 0.1, 0.2]
+for pad, ax in zip(pads, axs.flat):
+    pc = ax.pcolormesh(arr, **pc_kwargs)
+    fig.colorbar(pc, ax=ax, shrink=0.6, pad=pad)
+    ax.set_xticklabels([])
+    ax.set_yticklabels([])
+    ax.set_title(f'pad: {pad}')
+fig.get_layout_engine().set(w_pad=2 / 72, h_pad=2 / 72, hspace=0.2,
+                            wspace=0.2)
+
+# %%
+# rcParams
+# ========
+#
+# There are five :ref:`rcParams<customizing-with-dynamic-rc-settings>`
+# that can be set, either in a script or in the :file:`matplotlibrc`
+# file. They all have the prefix ``figure.constrained_layout``:
+#
+# - *use*: Whether to use *constrained layout*. Default is False
+# - *w_pad*, *h_pad*:    Padding around Axes objects.
+#   Float representing inches.  Default is 3./72. inches (3 pts)
+# - *wspace*, *hspace*:  Space between subplot groups.
+#   Float representing a fraction of the subplot widths being separated.
+#   Default is 0.02.
+
+plt.rcParams['figure.constrained_layout.use'] = True
+fig, axs = plt.subplots(2, 2, figsize=(3, 3))
+for ax in axs.flat:
+    example_plot(ax)
+
+# %%
+# Use with GridSpec
+# =================
+#
+# *Constrained layout* is meant to be used
+# with :func:`~matplotlib.figure.Figure.subplots`,
+# :func:`~matplotlib.figure.Figure.subplot_mosaic`, or
+# :func:`~matplotlib.gridspec.GridSpec` with
+# :func:`~matplotlib.figure.Figure.add_subplot`.
+#
+# Note that in what follows ``layout="constrained"``
+
+plt.rcParams['figure.constrained_layout.use'] = False
+fig = plt.figure(layout="constrained")
+
+gs1 = gridspec.GridSpec(2, 1, figure=fig)
+ax1 = fig.add_subplot(gs1[0])
+ax2 = fig.add_subplot(gs1[1])
+
+example_plot(ax1)
+example_plot(ax2)
+
+# %%
+# More complicated gridspec layouts are possible.  Note here we use the
+# convenience functions `~.Figure.add_gridspec` and
+# `~.SubplotSpec.subgridspec`.
+
+fig = plt.figure(layout="constrained")
+
+gs0 = fig.add_gridspec(1, 2)
+
+gs1 = gs0[0].subgridspec(2, 1)
+ax1 = fig.add_subplot(gs1[0])
+ax2 = fig.add_subplot(gs1[1])
+
+example_plot(ax1)
+example_plot(ax2)
+
+gs2 = gs0[1].subgridspec(3, 1)
+
+for ss in gs2:
+    ax = fig.add_subplot(ss)
+    example_plot(ax)
+    ax.set_title("")
+    ax.set_xlabel("")
+
+ax.set_xlabel("x-label", fontsize=12)
+
+# %%
+# Note that in the above the left and right columns don't have the same
+# vertical extent.  If we want the top and bottom of the two grids to line up
+# then they need to be in the same gridspec.  We need to make this figure
+# larger as well in order for the Axes not to collapse to zero height:
+
+fig = plt.figure(figsize=(4, 6), layout="constrained")
+
+gs0 = fig.add_gridspec(6, 2)
+
+ax1 = fig.add_subplot(gs0[:3, 0])
+ax2 = fig.add_subplot(gs0[3:, 0])
+
+example_plot(ax1)
+example_plot(ax2)
+
+ax = fig.add_subplot(gs0[0:2, 1])
+example_plot(ax, hide_labels=True)
+ax = fig.add_subplot(gs0[2:4, 1])
+example_plot(ax, hide_labels=True)
+ax = fig.add_subplot(gs0[4:, 1])
+example_plot(ax, hide_labels=True)
+fig.suptitle('Overlapping Gridspecs')
+
+# %%
+# This example uses two gridspecs to have the colorbar only pertain to
+# one set of pcolors.  Note how the left column is wider than the
+# two right-hand columns because of this.  Of course, if you wanted the
+# subplots to be the same size you only needed one gridspec.  Note that
+# the same effect can be achieved using `~.Figure.subfigures`.
+
+fig = plt.figure(layout="constrained")
+gs0 = fig.add_gridspec(1, 2, figure=fig, width_ratios=[1, 2])
+gs_left = gs0[0].subgridspec(2, 1)
+gs_right = gs0[1].subgridspec(2, 2)
+
+for gs in gs_left:
+    ax = fig.add_subplot(gs)
+    example_plot(ax)
+axs = []
+for gs in gs_right:
+    ax = fig.add_subplot(gs)
+    pcm = ax.pcolormesh(arr, **pc_kwargs)
+    ax.set_xlabel('x-label')
+    ax.set_ylabel('y-label')
+    ax.set_title('title')
+    axs += [ax]
+fig.suptitle('Nested plots using subgridspec')
+fig.colorbar(pcm, ax=axs)
+
+# %%
+# Rather than using subgridspecs, Matplotlib now provides `~.Figure.subfigures`
+# which also work with *constrained layout*:
+
+fig = plt.figure(layout="constrained")
+sfigs = fig.subfigures(1, 2, width_ratios=[1, 2])
+
+axs_left = sfigs[0].subplots(2, 1)
+for ax in axs_left.flat:
+    example_plot(ax)
+
+axs_right = sfigs[1].subplots(2, 2)
+for ax in axs_right.flat:
+    pcm = ax.pcolormesh(arr, **pc_kwargs)
+    ax.set_xlabel('x-label')
+    ax.set_ylabel('y-label')
+    ax.set_title('title')
+fig.colorbar(pcm, ax=axs_right)
+fig.suptitle('Nested plots using subfigures')
+
+# %%
+# Manually setting Axes positions
+# ================================
+#
+# There can be good reasons to manually set an Axes position.  A manual call
+# to `~.axes.Axes.set_position` will set the Axes so *constrained layout* has
+# no effect on it anymore. (Note that *constrained layout* still leaves the
+# space for the Axes that is moved).
+
+fig, axs = plt.subplots(1, 2, layout="constrained")
+example_plot(axs[0], fontsize=12)
+axs[1].set_position([0.2, 0.2, 0.4, 0.4])
+
+# %%
+# .. _compressed_layout:
+#
+# Grids of fixed aspect-ratio Axes: "compressed" layout
+# =====================================================
+#
+# *Constrained layout* operates on the grid of "original" positions for
+# Axes. However, when Axes have fixed aspect ratios, one side is usually made
+# shorter, and leaves large gaps in the shortened direction. In the following,
+# the Axes are square, but the figure quite wide so there is a horizontal gap:
+
+fig, axs = plt.subplots(2, 2, figsize=(5, 3),
+                        sharex=True, sharey=True, layout="constrained")
+for ax in axs.flat:
+    ax.imshow(arr)
+fig.suptitle("fixed-aspect plots, layout='constrained'")
+
+# %%
+# One obvious way of fixing this is to make the figure size more square,
+# however, closing the gaps exactly requires trial and error.  For simple grids
+# of Axes we can use ``layout="compressed"`` to do the job for us:
+
+fig, axs = plt.subplots(2, 2, figsize=(5, 3),
+                        sharex=True, sharey=True, layout='compressed')
+for ax in axs.flat:
+    ax.imshow(arr)
+fig.suptitle("fixed-aspect plots, layout='compressed'")
+
+
+# %%
+# Manually turning off *constrained layout*
+# ===========================================
+#
+# *Constrained layout* usually adjusts the Axes positions on each draw
+# of the figure.  If you want to get the spacing provided by
+# *constrained layout* but not have it update, then do the initial
+# draw and then call ``fig.set_layout_engine('none')``.
+# This is potentially useful for animations where the tick labels may
+# change length.
+#
+# Note that *constrained layout* is turned off for ``ZOOM`` and ``PAN``
+# GUI events for the backends that use the toolbar.  This prevents the
+# Axes from changing position during zooming and panning.
+#
+#
+# Limitations
+# ===========
+#
+# Incompatible functions
+# ----------------------
+#
+# *Constrained layout* will work with `.pyplot.subplot`, but only if the
+# number of rows and columns is the same for each call.
+# The reason is that each call to `.pyplot.subplot` will create a new
+# `.GridSpec` instance if the geometry is not the same, and
+# *constrained layout*.  So the following works fine:
+
+fig = plt.figure(layout="constrained")
+
+ax1 = plt.subplot(2, 2, 1)
+ax2 = plt.subplot(2, 2, 3)
+# third Axes that spans both rows in second column:
+ax3 = plt.subplot(2, 2, (2, 4))
+
+example_plot(ax1)
+example_plot(ax2)
+example_plot(ax3)
+plt.suptitle('Homogenous nrows, ncols')
+
+# %%
+# but the following leads to a poor layout:
+
+fig = plt.figure(layout="constrained")
+
+ax1 = plt.subplot(2, 2, 1)
+ax2 = plt.subplot(2, 2, 3)
+ax3 = plt.subplot(1, 2, 2)
+
+example_plot(ax1)
+example_plot(ax2)
+example_plot(ax3)
+plt.suptitle('Mixed nrows, ncols')
+
+# %%
+# Similarly,
+# `~matplotlib.pyplot.subplot2grid` works with the same limitation
+# that nrows and ncols cannot change for the layout to look good.
+
+fig = plt.figure(layout="constrained")
+
+ax1 = plt.subplot2grid((3, 3), (0, 0))
+ax2 = plt.subplot2grid((3, 3), (0, 1), colspan=2)
+ax3 = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=2)
+ax4 = plt.subplot2grid((3, 3), (1, 2), rowspan=2)
+
+example_plot(ax1)
+example_plot(ax2)
+example_plot(ax3)
+example_plot(ax4)
+fig.suptitle('subplot2grid')
+
+# %%
+# Other caveats
+# -------------
+#
+# * *Constrained layout* only considers ticklabels, axis labels, titles, and
+#   legends.  Thus, other artists may be clipped and also may overlap.
+#
+# * It assumes that the extra space needed for ticklabels, axis labels,
+#   and titles is independent of original location of Axes. This is
+#   often true, but there are rare cases where it is not.
+#
+# * There are small differences in how the backends handle rendering fonts,
+#   so the results will not be pixel-identical.
+#
+# * An artist using Axes coordinates that extend beyond the Axes
+#   boundary will result in unusual layouts when added to an
+#   Axes. This can be avoided by adding the artist directly to the
+#   :class:`~matplotlib.figure.Figure` using
+#   :meth:`~matplotlib.figure.Figure.add_artist`. See
+#   :class:`~matplotlib.patches.ConnectionPatch` for an example.
+
+# %%
+# Debugging
+# =========
+#
+# *Constrained layout* can fail in somewhat unexpected ways.  Because it uses
+# a constraint solver the solver can find solutions that are mathematically
+# correct, but that aren't at all what the user wants.  The usual failure
+# mode is for all sizes to collapse to their smallest allowable value. If
+# this happens, it is for one of two reasons:
+#
+# 1. There was not enough room for the elements you were requesting to draw.
+# 2. There is a bug - in which case open an issue at
+#    https://github.com/matplotlib/matplotlib/issues.
+#
+# If there is a bug, please report with a self-contained example that does
+# not require outside data or dependencies (other than numpy).
+
+# %%
+# .. _cl_notes_on_algorithm:
+#
+# Notes on the algorithm
+# ======================
+#
+# The algorithm for the constraint is relatively straightforward, but
+# has some complexity due to the complex ways we can lay out a figure.
+#
+# Layout in Matplotlib is carried out with gridspecs
+# via the `.GridSpec` class. A gridspec is a logical division of the figure
+# into rows and columns, with the relative width of the Axes in those
+# rows and columns set by *width_ratios* and *height_ratios*.
+#
+# In *constrained layout*, each gridspec gets a *layoutgrid* associated with
+# it.  The *layoutgrid* has a series of ``left`` and ``right`` variables
+# for each column, and ``bottom`` and ``top`` variables for each row, and
+# further it has a margin for each of left, right, bottom and top.  In each
+# row, the bottom/top margins are widened until all the decorators
+# in that row are accommodated.  Similarly, for columns and the left/right
+# margins.
+#
+#
+# Simple case: one Axes
+# ---------------------
+#
+# For a single Axes the layout is straight forward.  There is one parent
+# layoutgrid for the figure consisting of one column and row, and
+# a child layoutgrid for the gridspec that contains the Axes, again
+# consisting of one row and column. Space is made for the "decorations" on
+# each side of the Axes.  In the code, this is accomplished by the entries in
+# ``do_constrained_layout()`` like::
+#
+#     gridspec._layoutgrid[0, 0].edit_margin_min('left',
+#           -bbox.x0 + pos.x0 + w_pad)
+#
+# where ``bbox`` is the tight bounding box of the Axes, and ``pos`` its
+# position.  Note how the four margins encompass the Axes decorations.
+
+from matplotlib._layoutgrid import plot_children
+
+fig, ax = plt.subplots(layout="constrained")
+example_plot(ax, fontsize=24)
+plot_children(fig)
+
+# %%
+# Simple case: two Axes
+# ---------------------
+# When there are multiple Axes they have their layouts bound in
+# simple ways.  In this example the left Axes has much larger decorations
+# than the right, but they share a bottom margin, which is made large
+# enough to accommodate the larger xlabel.   Same with the shared top
+# margin.  The left and right margins are not shared, and hence are
+# allowed to be different.
+
+fig, ax = plt.subplots(1, 2, layout="constrained")
+example_plot(ax[0], fontsize=32)
+example_plot(ax[1], fontsize=8)
+plot_children(fig)
+
+# %%
+# Two Axes and colorbar
+# ---------------------
+#
+# A colorbar is simply another item that expands the margin of the parent
+# layoutgrid cell:
+
+fig, ax = plt.subplots(1, 2, layout="constrained")
+im = ax[0].pcolormesh(arr, **pc_kwargs)
+fig.colorbar(im, ax=ax[0], shrink=0.6)
+im = ax[1].pcolormesh(arr, **pc_kwargs)
+plot_children(fig)
+
+# %%
+# Colorbar associated with a Gridspec
+# -----------------------------------
+#
+# If a colorbar belongs to more than one cell of the grid, then
+# it makes a larger margin for each:
+
+fig, axs = plt.subplots(2, 2, layout="constrained")
+for ax in axs.flat:
+    im = ax.pcolormesh(arr, **pc_kwargs)
+fig.colorbar(im, ax=axs, shrink=0.6)
+plot_children(fig)
+
+# %%
+# Uneven sized Axes
+# -----------------
+#
+# There are two ways to make Axes have an uneven size in a
+# Gridspec layout, either by specifying them to cross Gridspecs rows
+# or columns, or by specifying width and height ratios.
+#
+# The first method is used here.  Note that the middle ``top`` and
+# ``bottom`` margins are not affected by the left-hand column.  This
+# is a conscious decision of the algorithm, and leads to the case where
+# the two right-hand Axes have the same height, but it is not 1/2 the height
+# of the left-hand Axes.  This is consistent with how ``gridspec`` works
+# without *constrained layout*.
+
+fig = plt.figure(layout="constrained")
+gs = gridspec.GridSpec(2, 2, figure=fig)
+ax = fig.add_subplot(gs[:, 0])
+im = ax.pcolormesh(arr, **pc_kwargs)
+ax = fig.add_subplot(gs[0, 1])
+im = ax.pcolormesh(arr, **pc_kwargs)
+ax = fig.add_subplot(gs[1, 1])
+im = ax.pcolormesh(arr, **pc_kwargs)
+plot_children(fig)
+
+# %%
+# One case that requires finessing is if margins do not have any artists
+# constraining their width. In the case below, the right margin for column 0
+# and the left margin for column 3 have no margin artists to set their width,
+# so we take the maximum width of the margin widths that do have artists.
+# This makes all the Axes have the same size:
+
+fig = plt.figure(layout="constrained")
+gs = fig.add_gridspec(2, 4)
+ax00 = fig.add_subplot(gs[0, 0:2])
+ax01 = fig.add_subplot(gs[0, 2:])
+ax10 = fig.add_subplot(gs[1, 1:3])
+example_plot(ax10, fontsize=14)
+plot_children(fig)
+plt.show()