Full Code of mwaskom/seaborn for AI

gitextract_2fyw04_k/

├── .github/
│   ├── CONTRIBUTING.md
│   ├── dependabot.yml
│   └── workflows/
│       └── ci.yaml
├── .gitignore
├── .pre-commit-config.yaml
├── CITATION.cff
├── LICENSE.md
├── Makefile
├── README.md
├── SECURITY.md
├── ci/
│   ├── cache_datasets.py
│   ├── check_gallery.py
│   ├── deps_pinned.txt
│   └── getmsfonts.sh
├── doc/
│   ├── .gitignore
│   ├── Makefile
│   ├── README.md
│   ├── _docstrings/
│   │   ├── FacetGrid.ipynb
│   │   ├── JointGrid.ipynb
│   │   ├── Makefile
│   │   ├── PairGrid.ipynb
│   │   ├── axes_style.ipynb
│   │   ├── barplot.ipynb
│   │   ├── blend_palette.ipynb
│   │   ├── boxenplot.ipynb
│   │   ├── boxplot.ipynb
│   │   ├── catplot.ipynb
│   │   ├── clustermap.ipynb
│   │   ├── color_palette.ipynb
│   │   ├── countplot.ipynb
│   │   ├── cubehelix_palette.ipynb
│   │   ├── dark_palette.ipynb
│   │   ├── displot.ipynb
│   │   ├── diverging_palette.ipynb
│   │   ├── ecdfplot.ipynb
│   │   ├── heatmap.ipynb
│   │   ├── histplot.ipynb
│   │   ├── hls_palette.ipynb
│   │   ├── husl_palette.ipynb
│   │   ├── jointplot.ipynb
│   │   ├── kdeplot.ipynb
│   │   ├── light_palette.ipynb
│   │   ├── lineplot.ipynb
│   │   ├── lmplot.ipynb
│   │   ├── move_legend.ipynb
│   │   ├── mpl_palette.ipynb
│   │   ├── objects.Agg.ipynb
│   │   ├── objects.Area.ipynb
│   │   ├── objects.Band.ipynb
│   │   ├── objects.Bar.ipynb
│   │   ├── objects.Bars.ipynb
│   │   ├── objects.Count.ipynb
│   │   ├── objects.Dash.ipynb
│   │   ├── objects.Dodge.ipynb
│   │   ├── objects.Dot.ipynb
│   │   ├── objects.Dots.ipynb
│   │   ├── objects.Est.ipynb
│   │   ├── objects.Hist.ipynb
│   │   ├── objects.Jitter.ipynb
│   │   ├── objects.KDE.ipynb
│   │   ├── objects.Line.ipynb
│   │   ├── objects.Lines.ipynb
│   │   ├── objects.Norm.ipynb
│   │   ├── objects.Path.ipynb
│   │   ├── objects.Paths.ipynb
│   │   ├── objects.Perc.ipynb
│   │   ├── objects.Plot.add.ipynb
│   │   ├── objects.Plot.config.ipynb
│   │   ├── objects.Plot.facet.ipynb
│   │   ├── objects.Plot.label.ipynb
│   │   ├── objects.Plot.layout.ipynb
│   │   ├── objects.Plot.limit.ipynb
│   │   ├── objects.Plot.on.ipynb
│   │   ├── objects.Plot.pair.ipynb
│   │   ├── objects.Plot.scale.ipynb
│   │   ├── objects.Plot.share.ipynb
│   │   ├── objects.Plot.theme.ipynb
│   │   ├── objects.Range.ipynb
│   │   ├── objects.Shift.ipynb
│   │   ├── objects.Stack.ipynb
│   │   ├── objects.Text.ipynb
│   │   ├── pairplot.ipynb
│   │   ├── plotting_context.ipynb
│   │   ├── pointplot.ipynb
│   │   ├── regplot.ipynb
│   │   ├── relplot.ipynb
│   │   ├── residplot.ipynb
│   │   ├── rugplot.ipynb
│   │   ├── scatterplot.ipynb
│   │   ├── set_context.ipynb
│   │   ├── set_style.ipynb
│   │   ├── set_theme.ipynb
│   │   ├── stripplot.ipynb
│   │   ├── swarmplot.ipynb
│   │   └── violinplot.ipynb
│   ├── _static/
│   │   ├── copybutton.js
│   │   └── css/
│   │       └── custom.css
│   ├── _templates/
│   │   ├── autosummary/
│   │   │   ├── base.rst
│   │   │   ├── class.rst
│   │   │   ├── object.rst
│   │   │   ├── plot.rst
│   │   │   └── scale.rst
│   │   ├── layout.html
│   │   └── version.html
│   ├── _tutorial/
│   │   ├── Makefile
│   │   ├── aesthetics.ipynb
│   │   ├── axis_grids.ipynb
│   │   ├── categorical.ipynb
│   │   ├── color_palettes.ipynb
│   │   ├── data_structure.ipynb
│   │   ├── distributions.ipynb
│   │   ├── error_bars.ipynb
│   │   ├── function_overview.ipynb
│   │   ├── introduction.ipynb
│   │   ├── objects_interface.ipynb
│   │   ├── properties.ipynb
│   │   ├── regression.ipynb
│   │   └── relational.ipynb
│   ├── api.rst
│   ├── citing.rst
│   ├── conf.py
│   ├── example_thumbs/
│   │   └── .gitkeep
│   ├── faq.rst
│   ├── index.rst
│   ├── installing.rst
│   ├── make.bat
│   ├── matplotlibrc
│   ├── sphinxext/
│   │   ├── gallery_generator.py
│   │   └── tutorial_builder.py
│   ├── tools/
│   │   ├── extract_examples.py
│   │   ├── generate_logos.py
│   │   ├── nb_to_doc.py
│   │   └── set_nb_kernels.py
│   ├── tutorial.yaml
│   └── whatsnew/
│       ├── index.rst
│       ├── v0.10.0.rst
│       ├── v0.10.1.rst
│       ├── v0.11.0.rst
│       ├── v0.11.1.rst
│       ├── v0.11.2.rst
│       ├── v0.12.0.rst
│       ├── v0.12.1.rst
│       ├── v0.12.2.rst
│       ├── v0.13.0.rst
│       ├── v0.13.1.rst
│       ├── v0.13.2.rst
│       ├── v0.2.0.rst
│       ├── v0.2.1.rst
│       ├── v0.3.0.rst
│       ├── v0.3.1.rst
│       ├── v0.4.0.rst
│       ├── v0.5.0.rst
│       ├── v0.5.1.rst
│       ├── v0.6.0.rst
│       ├── v0.7.0.rst
│       ├── v0.7.1.rst
│       ├── v0.8.0.rst
│       ├── v0.8.1.rst
│       ├── v0.9.0.rst
│       └── v0.9.1.rst
├── examples/
│   ├── .gitignore
│   ├── anscombes_quartet.py
│   ├── different_scatter_variables.py
│   ├── errorband_lineplots.py
│   ├── faceted_histogram.py
│   ├── faceted_lineplot.py
│   ├── grouped_barplot.py
│   ├── grouped_boxplot.py
│   ├── grouped_violinplots.py
│   ├── heat_scatter.py
│   ├── hexbin_marginals.py
│   ├── histogram_stacked.py
│   ├── horizontal_boxplot.py
│   ├── jitter_stripplot.py
│   ├── joint_histogram.py
│   ├── joint_kde.py
│   ├── kde_ridgeplot.py
│   ├── large_distributions.py
│   ├── layered_bivariate_plot.py
│   ├── logistic_regression.py
│   ├── many_facets.py
│   ├── many_pairwise_correlations.py
│   ├── marginal_ticks.py
│   ├── multiple_bivariate_kde.py
│   ├── multiple_conditional_kde.py
│   ├── multiple_ecdf.py
│   ├── multiple_regression.py
│   ├── pair_grid_with_kde.py
│   ├── paired_pointplots.py
│   ├── pairgrid_dotplot.py
│   ├── palette_choices.py
│   ├── palette_generation.py
│   ├── part_whole_bars.py
│   ├── pointplot_anova.py
│   ├── radial_facets.py
│   ├── regression_marginals.py
│   ├── residplot.py
│   ├── scatter_bubbles.py
│   ├── scatterplot_categorical.py
│   ├── scatterplot_matrix.py
│   ├── scatterplot_sizes.py
│   ├── simple_violinplots.py
│   ├── smooth_bivariate_kde.py
│   ├── spreadsheet_heatmap.py
│   ├── strip_regplot.py
│   ├── structured_heatmap.py
│   ├── three_variable_histogram.py
│   ├── timeseries_facets.py
│   ├── wide_data_lineplot.py
│   └── wide_form_violinplot.py
├── licences/
│   ├── APPDIRS_LICENSE
│   ├── HUSL_LICENSE
│   ├── NUMPYDOC_LICENSE
│   ├── PACKAGING_LICENSE
│   └── SCIPY_LICENSE
├── pyproject.toml
├── seaborn/
│   ├── __init__.py
│   ├── _base.py
│   ├── _compat.py
│   ├── _core/
│   │   ├── __init__.py
│   │   ├── data.py
│   │   ├── exceptions.py
│   │   ├── groupby.py
│   │   ├── moves.py
│   │   ├── plot.py
│   │   ├── properties.py
│   │   ├── rules.py
│   │   ├── scales.py
│   │   ├── subplots.py
│   │   └── typing.py
│   ├── _docstrings.py
│   ├── _marks/
│   │   ├── __init__.py
│   │   ├── area.py
│   │   ├── bar.py
│   │   ├── base.py
│   │   ├── dot.py
│   │   ├── line.py
│   │   └── text.py
│   ├── _statistics.py
│   ├── _stats/
│   │   ├── __init__.py
│   │   ├── aggregation.py
│   │   ├── base.py
│   │   ├── counting.py
│   │   ├── density.py
│   │   ├── order.py
│   │   └── regression.py
│   ├── _testing.py
│   ├── algorithms.py
│   ├── axisgrid.py
│   ├── categorical.py
│   ├── cm.py
│   ├── colors/
│   │   ├── __init__.py
│   │   ├── crayons.py
│   │   └── xkcd_rgb.py
│   ├── distributions.py
│   ├── external/
│   │   ├── __init__.py
│   │   ├── appdirs.py
│   │   ├── docscrape.py
│   │   ├── husl.py
│   │   ├── kde.py
│   │   └── version.py
│   ├── matrix.py
│   ├── miscplot.py
│   ├── objects.py
│   ├── palettes.py
│   ├── rcmod.py
│   ├── regression.py
│   ├── relational.py
│   ├── utils.py
│   └── widgets.py
├── setup.cfg
└── tests/
    ├── __init__.py
    ├── _core/
    │   ├── __init__.py
    │   ├── test_data.py
    │   ├── test_groupby.py
    │   ├── test_moves.py
    │   ├── test_plot.py
    │   ├── test_properties.py
    │   ├── test_rules.py
    │   ├── test_scales.py
    │   └── test_subplots.py
    ├── _marks/
    │   ├── __init__.py
    │   ├── test_area.py
    │   ├── test_bar.py
    │   ├── test_base.py
    │   ├── test_dot.py
    │   ├── test_line.py
    │   └── test_text.py
    ├── _stats/
    │   ├── __init__.py
    │   ├── test_aggregation.py
    │   ├── test_counting.py
    │   ├── test_density.py
    │   ├── test_order.py
    │   └── test_regression.py
    ├── conftest.py
    ├── test_algorithms.py
    ├── test_axisgrid.py
    ├── test_base.py
    ├── test_categorical.py
    ├── test_distributions.py
    ├── test_docstrings.py
    ├── test_matrix.py
    ├── test_miscplot.py
    ├── test_objects.py
    ├── test_palettes.py
    ├── test_rcmod.py
    ├── test_regression.py
    ├── test_relational.py
    ├── test_statistics.py
    └── test_utils.py

SYMBOL INDEX (2798 symbols across 85 files)

FILE: doc/sphinxext/gallery_generator.py
  function execfile (line 22) | def execfile(filename, globals=None, locals=None):
  function create_thumbnail (line 128) | def create_thumbnail(infile, thumbfile,
  function indent (line 159) | def indent(s, N=4):
  class ExampleGenerator (line 164) | class ExampleGenerator:
    method __init__ (line 166) | def __init__(self, filename, target_dir):
    method dirname (line 185) | def dirname(self):
    method fname (line 189) | def fname(self):
    method modulename (line 193) | def modulename(self):
    method pyfilename (line 197) | def pyfilename(self):
    method rstfilename (line 201) | def rstfilename(self):
    method htmlfilename (line 205) | def htmlfilename(self):
    method pngfilename (line 209) | def pngfilename(self):
    method thumbfilename (line 214) | def thumbfilename(self):
    method sphinxtag (line 219) | def sphinxtag(self):
    method pagetitle (line 223) | def pagetitle(self):
    method plotfunc (line 227) | def plotfunc(self):
    method components (line 240) | def components(self):
    method extract_docstring (line 252) | def extract_docstring(self):
    method exec_file (line 295) | def exec_file(self):
    method toctree_entry (line 313) | def toctree_entry(self):
    method contents_entry (line 316) | def contents_entry(self):
  function main (line 332) | def main(app):
  function setup (line 392) | def setup(app):

FILE: doc/sphinxext/tutorial_builder.py
  function main (line 49) | def main(app):
  function write_thumbnail (line 79) | def write_thumbnail(svg_path, page):
  function introduction (line 95) | def introduction():
  function function_overview (line 130) | def function_overview():
  function data_structure (line 182) | def data_structure():
  function error_bars (line 204) | def error_bars():
  function properties (line 217) | def properties():
  function objects_interface (line 246) | def objects_interface():
  function relational (line 274) | def relational():
  function distributions (line 287) | def distributions():
  function categorical (line 300) | def categorical():
  function regression (line 313) | def regression():
  function axis_grids (line 327) | def axis_grids():
  function aesthetics (line 340) | def aesthetics():
  function color_palettes (line 352) | def color_palettes():
  function setup (line 365) | def setup(app):

FILE: doc/tools/extract_examples.py
  function line_type (line 10) | def line_type(line):
  function add_cell (line 18) | def add_cell(nb, lines, cell_type):

FILE: doc/tools/generate_logos.py
  function poisson_disc_sample (line 15) | def poisson_disc_sample(array_radius, pad_radius, candidates=100, d=2, s...
  function logo (line 61) | def logo(
  function savefig (line 159) | def savefig(fig, shape, variant):

FILE: doc/tools/nb_to_doc.py
  class MetadataError (line 41) | class MetadataError(Exception):
  function pop_recursive (line 45) | def pop_recursive(d, key, default=None):
  function strip_output (line 65) | def strip_output(nb):

FILE: examples/kde_ridgeplot.py
  function label (line 36) | def label(x, color, label):

FILE: seaborn/_base.py
  class SemanticMapping (line 29) | class SemanticMapping:
    method __init__ (line 43) | def __init__(self, plotter):
    method _check_list_length (line 52) | def _check_list_length(self, levels, values, variable):
    method _lookup_single (line 76) | def _lookup_single(self, key):
    method __call__ (line 80) | def __call__(self, key, *args, **kwargs):
  class HueMapping (line 88) | class HueMapping(SemanticMapping):
    method __init__ (line 99) | def __init__(
    method _lookup_single (line 173) | def _lookup_single(self, key):
    method infer_map_type (line 205) | def infer_map_type(self, palette, norm, input_format, var_type):
    method categorical_mapping (line 220) | def categorical_mapping(self, data, palette, order):
    method numeric_mapping (line 254) | def numeric_mapping(self, data, palette, norm):
  class SizeMapping (line 298) | class SizeMapping(SemanticMapping):
    method __init__ (line 303) | def __init__(
    method infer_map_type (line 359) | def infer_map_type(self, norm, sizes, var_type):
    method _lookup_single (line 370) | def _lookup_single(self, key):
    method categorical_mapping (line 381) | def categorical_mapping(self, data, sizes, order):
    method numeric_mapping (line 439) | def numeric_mapping(self, data, sizes, norm):
  class StyleMapping (line 519) | class StyleMapping(SemanticMapping):
    method __init__ (line 525) | def __init__(self, plotter, markers=None, dashes=None, order=None):
    method _lookup_single (line 583) | def _lookup_single(self, key, attr=None):
    method _map_attributes (line 591) | def _map_attributes(self, arg, levels, defaults, attr):
  class VectorPlotter (line 616) | class VectorPlotter:
    method __init__ (line 626) | def __init__(self, data=None, variables={}):
    method has_xy_data (line 644) | def has_xy_data(self):
    method var_levels (line 649) | def var_levels(self):
    method assign_variables (line 666) | def assign_variables(self, data=None, variables={}):
    method _assign_variables_wideform (line 695) | def _assign_variables_wideform(self, data=None, **kwargs):
    method map_hue (line 836) | def map_hue(self, palette=None, order=None, norm=None, saturation=1):
    method map_size (line 840) | def map_size(self, sizes=None, order=None, norm=None):
    method map_style (line 844) | def map_style(self, markers=None, dashes=None, order=None):
    method iter_data (line 848) | def iter_data(
    method comp_data (line 968) | def comp_data(self):
    method _get_axes (line 1012) | def _get_axes(self, sub_vars):
    method _attach (line 1027) | def _attach(
    method _get_scale_transforms (line 1166) | def _get_scale_transforms(self, axis):
    method _add_axis_labels (line 1188) | def _add_axis_labels(self, ax, default_x="", default_y=""):
    method add_legend_data (line 1201) | def add_legend_data(
    method _update_legend_data (line 1283) | def _update_legend_data(
    method scale_native (line 1337) | def scale_native(self, axis, *args, **kwargs):
    method scale_numeric (line 1343) | def scale_numeric(self, axis, *args, **kwargs):
    method scale_datetime (line 1350) | def scale_datetime(self, axis, *args, **kwargs):
    method scale_categorical (line 1357) | def scale_categorical(self, axis, order=None, formatter=None):
  class VariableType (line 1451) | class VariableType(UserString):
    method __init__ (line 1462) | def __init__(self, data):
    method __eq__ (line 1466) | def __eq__(self, other):
  function variable_type (line 1471) | def variable_type(vector, boolean_type="numeric"):
  function infer_orient (line 1563) | def infer_orient(x=None, y=None, orient=None, require_numeric=True):
  function unique_dashes (line 1646) | def unique_dashes(n):
  function unique_markers (line 1697) | def unique_markers(n):
  function categorical_order (line 1743) | def categorical_order(vector, order=None):

FILE: seaborn/_compat.py
  function norm_from_scale (line 11) | def norm_from_scale(scale, norm):
  function get_colormap (line 59) | def get_colormap(name):
  function register_colormap (line 67) | def register_colormap(name, cmap):
  function set_layout_engine (line 76) | def set_layout_engine(
  function get_layout_engine (line 94) | def get_layout_engine(fig: Figure) -> mpl.layout_engine.LayoutEngine | N...
  function share_axis (line 103) | def share_axis(ax0, ax1, which):
  function get_legend_handles (line 112) | def get_legend_handles(legend):
  function groupby_apply_include_groups (line 120) | def groupby_apply_include_groups(val):
  function get_converter (line 126) | def get_converter(axis):

FILE: seaborn/_core/data.py
  class PlotData (line 15) | class PlotData:
    method __init__ (line 49) | def __init__(
    method __contains__ (line 72) | def __contains__(self, key: str) -> bool:
    method join (line 78) | def join(
    method _assign_variables (line 125) | def _assign_variables(
  function handle_data_source (line 268) | def handle_data_source(data: DataSource) -> pd.DataFrame | Mapping | None:

FILE: seaborn/_core/exceptions.py
  class PlotSpecError (line 10) | class PlotSpecError(RuntimeError):
    method _during (line 22) | def _during(cls, step: str, var: str = "") -> PlotSpecError:

FILE: seaborn/_core/groupby.py
  class GroupBy (line 16) | class GroupBy:
    method __init__ (line 29) | def __init__(self, order: list[str] | dict[str, list | None]):
    method _get_groups (line 49) | def _get_groups(
    method _reorder_columns (line 73) | def _reorder_columns(self, res, data):
    method agg (line 79) | def agg(self, data: DataFrame, *args, **kwargs) -> DataFrame:
    method apply (line 105) | def apply(

FILE: seaborn/_core/moves.py
  class Move (line 16) | class Move:
    method __call__ (line 21) | def __call__(
  class Jitter (line 28) | class Jitter(Move):
    method __call__ (line 53) | def __call__(
  class Dodge (line 81) | class Dodge(Move):
    method __call__ (line 106) | def __call__(
  class Stack (line 154) | class Stack(Move):
    method _stack (line 165) | def _stack(self, df, orient):
    method __call__ (line 183) | def __call__(
  class Shift (line 194) | class Shift(Move):
    method __call__ (line 211) | def __call__(
  class Norm (line 222) | class Norm(Move):
    method _norm (line 250) | def _norm(self, df, var):
    method __call__ (line 263) | def __call__(

FILE: seaborn/_core/plot.py
  class Layer (line 59) | class Layer(TypedDict, total=False):
  class FacetSpec (line 72) | class FacetSpec(TypedDict, total=False):
  class PairSpec (line 79) | class PairSpec(TypedDict, total=False):
  function theme_context (line 91) | def theme_context(params: dict[str, Any]) -> Generator:
  function build_plot_signature (line 109) | def build_plot_signature(cls):
  class ThemeConfig (line 144) | class ThemeConfig(mpl.RcParams):
    method __init__ (line 154) | def __init__(self):
    method _default (line 159) | def _default(self) -> dict[str, Any]:
    method reset (line 168) | def reset(self) -> None:
    method update (line 172) | def update(self, other: dict[str, Any] | None = None, /, **kwds):
    method _filter_params (line 181) | def _filter_params(self, params: dict[str, Any]) -> dict[str, Any]:
    method _html_table (line 188) | def _html_table(self, params: dict[str, Any]) -> list[str]:
    method _repr_html_ (line 197) | def _repr_html_(self) -> str:
  class DisplayConfig (line 209) | class DisplayConfig(TypedDict):
  class PlotConfig (line 216) | class PlotConfig:
    method __init__ (line 218) | def __init__(self):
    method theme (line 224) | def theme(self) -> dict[str, Any]:
    method display (line 235) | def display(self) -> DisplayConfig:
  class Plot (line 253) | class Plot:
    method __init__ (line 305) | def __init__(
    method _resolve_positionals (line 339) | def _resolve_positionals(
    method __add__ (line 375) | def __add__(self, other):
    method _repr_png_ (line 383) | def _repr_png_(self) -> tuple[bytes, dict[str, float]] | None:
    method _repr_svg_ (line 389) | def _repr_svg_(self) -> str | None:
    method _clone (line 395) | def _clone(self) -> Plot:
    method _theme_with_defaults (line 421) | def _theme_with_defaults(self) -> dict[str, Any]:
    method _variables (line 428) | def _variables(self) -> list[str]:
    method on (line 442) | def on(self, target: Axes | SubFigure | Figure) -> Plot:
    method add (line 484) | def add(
    method pair (line 577) | def pair(
    method facet (line 640) | def facet(
    method scale (line 703) | def scale(self, **scales: Scale) -> Plot:
    method share (line 730) | def share(self, **shares: bool | str) -> Plot:
    method limit (line 749) | def limit(self, **limits: tuple[Any, Any]) -> Plot:
    method label (line 770) | def label(
    method layout (line 809) | def layout(
    method theme (line 862) | def theme(self, config: Mapping[str, Any], /) -> Plot:
    method save (line 889) | def save(self, loc, **kwargs) -> Plot:
    method show (line 907) | def show(self, **kwargs) -> None:
    method plot (line 927) | def plot(self, pyplot: bool = False) -> Plotter:
    method _plot (line 934) | def _plot(self, pyplot: bool = False) -> Plotter:
  class Plotter (line 974) | class Plotter:
    method __init__ (line 986) | def __init__(self, pyplot: bool, theme: dict[str, Any]):
    method save (line 995) | def save(self, loc, **kwargs) -> Plotter:  # TODO type args
    method show (line 1005) | def show(self, **kwargs) -> None:
    method _repr_png_ (line 1021) | def _repr_png_(self) -> tuple[bytes, dict[str, float]] | None:
    method _repr_svg_ (line 1050) | def _repr_svg_(self) -> str | None:
    method _extract_data (line 1071) | def _extract_data(self, p: Plot) -> tuple[PlotData, list[Layer]]:
    method _resolve_label (line 1087) | def _resolve_label(self, p: Plot, var: str, auto_label: str | None) ->...
    method _setup_figure (line 1107) | def _setup_figure(self, p: Plot, common: PlotData, layers: list[Layer]...
    method _compute_stats (line 1209) | def _compute_stats(self, spec: Plot, layers: list[Layer]) -> None:
    method _get_scale (line 1263) | def _get_scale(
    method _get_subplot_data (line 1283) | def _get_subplot_data(self, df, var, view, share_state):
    method _setup_scales (line 1305) | def _setup_scales(
    method _plot_layer (line 1417) | def _plot_layer(self, p: Plot, layer: Layer) -> None:
    method _unscale_coords (line 1497) | def _unscale_coords(
    method _generate_pairings (line 1522) | def _generate_pairings(
    method _get_subplot_index (line 1564) | def _get_subplot_index(self, df: DataFrame, subplot: dict) -> Index:
    method _filter_subplot_data (line 1575) | def _filter_subplot_data(self, df: DataFrame, subplot: dict) -> DataFr...
    method _setup_split_generator (line 1586) | def _setup_split_generator(
    method _update_legend_contents (line 1666) | def _update_legend_contents(
    method _make_legend (line 1730) | def _make_legend(self, p: Plot) -> None:
    method _finalize_figure (line 1779) | def _finalize_figure(self, p: Plot) -> None:

FILE: seaborn/_core/properties.py
  class Property (line 44) | class Property:
    method __init__ (line 53) | def __init__(self, variable: str | None = None):
    method default_scale (line 59) | def default_scale(self, data: Series) -> Scale:
    method infer_scale (line 72) | def infer_scale(self, arg: Any, data: Series) -> Scale:
    method get_mapping (line 92) | def get_mapping(self, scale: Scale, data: Series) -> Mapping:
    method standardize (line 98) | def standardize(self, val: Any) -> Any:
    method _check_dict_entries (line 102) | def _check_dict_entries(self, levels: list, values: dict) -> None:
    method _check_list_length (line 110) | def _check_list_length(self, levels: list, values: list) -> list:
  class Coordinate (line 140) | class Coordinate(Property):
  class IntervalProperty (line 151) | class IntervalProperty(Property):
    method default_range (line 159) | def default_range(self) -> tuple[float, float]:
    method _forward (line 163) | def _forward(self, values: ArrayLike) -> ArrayLike:
    method _inverse (line 167) | def _inverse(self, values: ArrayLike) -> ArrayLike:
    method infer_scale (line 171) | def infer_scale(self, arg: Any, data: Series) -> Scale:
    method get_mapping (line 190) | def get_mapping(self, scale: Scale, data: Series) -> Mapping:
    method _get_nominal_mapping (line 218) | def _get_nominal_mapping(self, scale: Nominal, data: Series) -> Mapping:
    method _get_boolean_mapping (line 232) | def _get_boolean_mapping(self, scale: Boolean, data: Series) -> Mapping:
    method _get_values (line 244) | def _get_values(self, scale: Scale, levels: list) -> list:
  class PointSize (line 270) | class PointSize(IntervalProperty):
    method _forward (line 274) | def _forward(self, values):
    method _inverse (line 278) | def _inverse(self, values):
  class LineWidth (line 283) | class LineWidth(IntervalProperty):
    method default_range (line 286) | def default_range(self) -> tuple[float, float]:
  class EdgeWidth (line 292) | class EdgeWidth(IntervalProperty):
    method default_range (line 295) | def default_range(self) -> tuple[float, float]:
  class Stroke (line 301) | class Stroke(IntervalProperty):
  class Alpha (line 306) | class Alpha(IntervalProperty):
  class Offset (line 312) | class Offset(IntervalProperty):
  class FontSize (line 318) | class FontSize(IntervalProperty):
    method default_range (line 323) | def default_range(self) -> tuple[float, float]:
  class ObjectProperty (line 334) | class ObjectProperty(Property):
    method _default_values (line 343) | def _default_values(self, n: int) -> list:
    method default_scale (line 346) | def default_scale(self, data: Series) -> Scale:
    method infer_scale (line 350) | def infer_scale(self, arg: Any, data: Series) -> Scale:
    method get_mapping (line 354) | def get_mapping(self, scale: Scale, data: Series) -> Mapping:
    method _get_values (line 373) | def _get_values(self, scale: Scale, levels: list) -> list:
  class Marker (line 394) | class Marker(ObjectProperty):
    method standardize (line 403) | def standardize(self, val: MarkerPattern) -> MarkerStyle:
    method _default_values (line 406) | def _default_values(self, n: int) -> list[MarkerStyle]:
  class LineStyle (line 438) | class LineStyle(ObjectProperty):
    method standardize (line 442) | def standardize(self, val: str | DashPattern) -> DashPatternWithOffset:
    method _default_values (line 445) | def _default_values(self, n: int) -> list[DashPatternWithOffset]:
    method _get_dash_pattern (line 489) | def _get_dash_pattern(style: str | DashPattern) -> DashPatternWithOffset:
  class TextAlignment (line 535) | class TextAlignment(ObjectProperty):
  class HorizontalAlignment (line 539) | class HorizontalAlignment(TextAlignment):
    method _default_values (line 541) | def _default_values(self, n: int) -> list:
  class VerticalAlignment (line 546) | class VerticalAlignment(TextAlignment):
    method _default_values (line 548) | def _default_values(self, n: int) -> list:
  class Color (line 558) | class Color(Property):
    method standardize (line 563) | def standardize(self, val: ColorSpec) -> RGBTuple | RGBATuple:
    method _standardize_color_sequence (line 571) | def _standardize_color_sequence(self, colors: ArrayLike) -> ArrayLike:
    method infer_scale (line 586) | def infer_scale(self, arg: Any, data: Series) -> Scale:
    method get_mapping (line 627) | def get_mapping(self, scale: Scale, data: Series) -> Mapping:
    method _get_nominal_mapping (line 668) | def _get_nominal_mapping(self, scale: Nominal, data: Series) -> Mapping:
    method _get_boolean_mapping (line 682) | def _get_boolean_mapping(self, scale: Boolean, data: Series) -> Mapping:
    method _get_values (line 697) | def _get_values(self, scale: Scale, levels: list) -> ArrayLike:
  class Fill (line 732) | class Fill(Property):
    method default_scale (line 737) | def default_scale(self, data: Series) -> Scale:
    method infer_scale (line 741) | def infer_scale(self, arg: Any, data: Series) -> Scale:
    method standardize (line 745) | def standardize(self, val: Any) -> bool:
    method _default_values (line 748) | def _default_values(self, n: int) -> list:
    method get_mapping (line 759) | def get_mapping(self, scale: Scale, data: Series) -> Mapping:
    method _get_values (line 778) | def _get_values(self, scale: Scale, levels: list) -> list:

FILE: seaborn/_core/rules.py
  class VarType (line 17) | class VarType(UserString):
    method __init__ (line 29) | def __init__(self, data):
    method __eq__ (line 33) | def __eq__(self, other):
  function variable_type (line 38) | def variable_type(
  function categorical_order (line 145) | def categorical_order(vector: Series, order: list | None = None) -> list:

FILE: seaborn/_core/scales.py
  class Scale (line 55) | class Scale:
    method __post_init__ (line 66) | def __post_init__(self):
    method tick (line 72) | def tick(self):
    method label (line 75) | def label(self):
    method _get_locators (line 78) | def _get_locators(self):
    method _get_formatter (line 81) | def _get_formatter(self, locator: Locator | None = None):
    method _get_scale (line 84) | def _get_scale(self, name: str, forward: Callable, inverse: Callable):
    method _spacing (line 98) | def _spacing(self, x: Series) -> float:
    method _setup (line 106) | def _setup(
    method _finalize (line 111) | def _finalize(self, p: Plot, axis: Axis) -> None:
    method __call__ (line 115) | def __call__(self, data: Series) -> ArrayLike:
    method _identity (line 137) | def _identity():
  class Boolean (line 149) | class Boolean(Scale):
    method _setup (line 164) | def _setup(
    method _finalize (line 202) | def _finalize(self, p: Plot, axis: Axis) -> None:
    method tick (line 220) | def tick(self, locator: Locator | None = None):
    method label (line 225) | def label(self, formatter: Formatter | None = None):
    method _get_locators (line 230) | def _get_locators(self, locator):
    method _get_formatter (line 235) | def _get_formatter(self, locator, formatter):
  class Nominal (line 242) | class Nominal(Scale):
    method _setup (line 253) | def _setup(
    method _finalize (line 324) | def _finalize(self, p: Plot, axis: Axis) -> None:
    method tick (line 337) | def tick(self, locator: Locator | None = None) -> Nominal:
    method label (line 359) | def label(self, formatter: Formatter | None = None) -> Nominal:
    method _get_locators (line 382) | def _get_locators(self, locator):
    method _get_formatter (line 391) | def _get_formatter(self, locator, formatter):
  class Ordinal (line 402) | class Ordinal(Scale):
  class Discrete (line 408) | class Discrete(Scale):
  class ContinuousBase (line 414) | class ContinuousBase(Scale):
    method _setup (line 419) | def _setup(
    method _get_transform (line 491) | def _get_transform(self):
  class Continuous (line 526) | class Continuous(ContinuousBase):
    method tick (line 538) | def tick(
    method label (line 599) | def label(
    method _parse_for_log_params (line 651) | def _parse_for_log_params(
    method _get_locators (line 665) | def _get_locators(self, locator, at, upto, count, every, between, minor):
    method _get_formatter (line 721) | def _get_formatter(self, locator, formatter, like, base, unit):
  class Temporal (line 762) | class Temporal(ContinuousBase):
    method tick (line 780) | def tick(
    method label (line 814) | def label(
    method _get_locators (line 843) | def _get_locators(self, locator, upto):
    method _get_formatter (line 856) | def _get_formatter(self, locator, formatter, concise):
  class PseudoAxis (line 889) | class PseudoAxis:
    method __init__ (line 901) | def __init__(self, scale):
    method set_view_interval (line 916) | def set_view_interval(self, vmin, vmax):
    method get_view_interval (line 919) | def get_view_interval(self):
    method set_data_interval (line 927) | def set_data_interval(self, vmin, vmax):
    method get_data_interval (line 930) | def get_data_interval(self):
    method get_tick_space (line 933) | def get_tick_space(self):
    method set_major_locator (line 938) | def set_major_locator(self, locator):
    method set_major_formatter (line 942) | def set_major_formatter(self, formatter):
    method set_minor_locator (line 946) | def set_minor_locator(self, locator):
    method set_minor_formatter (line 950) | def set_minor_formatter(self, formatter):
    method set_units (line 954) | def set_units(self, units):
    method update_units (line 957) | def update_units(self, x):
    method convert_units (line 975) | def convert_units(self, x):
    method get_scale (line 983) | def get_scale(self):
    method get_majorticklocs (line 991) | def get_majorticklocs(self):
  function _make_identity_transforms (line 999) | def _make_identity_transforms() -> TransFuncs:
  function _make_logit_transforms (line 1007) | def _make_logit_transforms(base: float | None = None) -> TransFuncs:
  function _make_log_transforms (line 1022) | def _make_log_transforms(base: float | None = None) -> TransFuncs:
  function _make_symlog_transforms (line 1047) | def _make_symlog_transforms(c: float = 1, base: float = 10) -> TransFuncs:
  function _make_sqrt_transforms (line 1067) | def _make_sqrt_transforms() -> TransFuncs:
  function _make_power_transforms (line 1078) | def _make_power_transforms(exp: float) -> TransFuncs:
  function _default_spacer (line 1089) | def _default_spacer(x: Series) -> float:

FILE: seaborn/_core/subplots.py
  class Subplots (line 16) | class Subplots:
    method __init__ (line 32) | def __init__(
    method _check_dimension_uniqueness (line 46) | def _check_dimension_uniqueness(
    method _determine_grid_dimensions (line 78) | def _determine_grid_dimensions(
    method _handle_wrapping (line 102) | def _handle_wrapping(
    method _determine_axis_sharing (line 121) | def _determine_axis_sharing(self, pair_spec: PairSpec) -> None:
    method init_figure (line 142) | def init_figure(
    method __iter__ (line 257) | def __iter__(self) -> Generator[dict, None, None]:  # TODO TypedDict?
    method __len__ (line 261) | def __len__(self) -> int:

FILE: seaborn/_core/typing.py
  class DataFrameProtocol (line 23) | class DataFrameProtocol(Protocol):
    method to_pandas (line 25) | def to_pandas(self) -> DataFrame:
  class Default (line 43) | class Default:
    method __repr__ (line 44) | def __repr__(self):
  class Deprecated (line 48) | class Deprecated:
    method __repr__ (line 49) | def __repr__(self):

FILE: seaborn/_docstrings.py
  class DocstringComponents (line 6) | class DocstringComponents:
    method __init__ (line 10) | def __init__(self, comp_dict, strip_whitespace=True):
    method __getattr__ (line 25) | def __getattr__(self, attr):
    method from_nested_components (line 44) | def from_nested_components(cls, **kwargs):
    method from_function_params (line 49) | def from_function_params(cls, func):

FILE: seaborn/_marks/area.py
  class AreaBase (line 21) | class AreaBase:
    method _plot (line 23) | def _plot(self, split_gen, scales, orient):
    method _standardize_coordinate_parameters (line 53) | def _standardize_coordinate_parameters(self, data, orient):
    method _postprocess_artist (line 56) | def _postprocess_artist(self, artist, ax, orient):
    method _get_verts (line 59) | def _get_verts(self, data, orient):
    method _legend_artist (line 71) | def _legend_artist(self, variables, value, scales):
  class Area (line 91) | class Area(AreaBase, Mark):
    method _standardize_coordinate_parameters (line 115) | def _standardize_coordinate_parameters(self, data, orient):
    method _postprocess_artist (line 119) | def _postprocess_artist(self, artist, ax, orient):
  class Band (line 141) | class Band(AreaBase, Mark):
    method _standardize_coordinate_parameters (line 162) | def _standardize_coordinate_parameters(self, data, orient):

FILE: seaborn/_marks/bar.py
  class BarBase (line 27) | class BarBase(Mark):
    method _make_patches (line 29) | def _make_patches(self, data, scales, orient):
    method _resolve_properties (line 80) | def _resolve_properties(self, data, scales):
    method _legend_artist (line 96) | def _legend_artist(
  class Bar (line 113) | class Bar(BarBase):
    method _plot (line 138) | def _plot(self, split_gen, scales, orient):
  class Bars (line 180) | class Bars(BarBase):
    method _plot (line 205) | def _plot(self, split_gen, scales, orient):

FILE: seaborn/_marks/base.py
  class Mappable (line 26) | class Mappable:
    method __init__ (line 27) | def __init__(
    method __repr__ (line 63) | def __repr__(self):
    method depend (line 78) | def depend(self) -> Any:
    method grouping (line 83) | def grouping(self) -> bool:
    method default (line 87) | def default(self) -> Any:
  class Mark (line 105) | class Mark:
    method _mappable_props (line 111) | def _mappable_props(self):
    method _grouping_props (line 118) | def _grouping_props(self):
    method _resolve (line 127) | def _resolve(
    method _infer_orient (line 200) | def _infer_orient(self, scales: dict) -> str:  # TODO type scales
    method _plot (line 216) | def _plot(
    method _legend_artist (line 225) | def _legend_artist(
  function resolve_properties (line 232) | def resolve_properties(
  function resolve_color (line 242) | def resolve_color(
  function document_properties (line 298) | def document_properties(mark):

FILE: seaborn/_marks/dot.py
  class DotBase (line 27) | class DotBase(Mark):
    method _resolve_paths (line 29) | def _resolve_paths(self, data):
    method _resolve_properties (line 47) | def _resolve_properties(self, data, scales):
    method _plot (line 62) | def _plot(self, split_gen, scales, orient):
    method _legend_artist (line 87) | def _legend_artist(
  class Dot (line 108) | class Dot(DotBase):
    method _resolve_properties (line 132) | def _resolve_properties(self, data, scales):
  class Dots (line 162) | class Dots(DotBase):
    method _resolve_properties (line 185) | def _resolve_properties(self, data, scales):

FILE: seaborn/_marks/line.py
  class Path (line 22) | class Path(Mark):
    method _plot (line 48) | def _plot(self, split_gen, scales, orient):
    method _legend_artist (line 78) | def _legend_artist(self, variables, value, scales):
    method _handle_capstyle (line 102) | def _handle_capstyle(self, kws, vals):
  class Line (line 113) | class Line(Path):
  class Paths (line 132) | class Paths(Mark):
    method __post_init__ (line 152) | def __post_init__(self):
    method _plot (line 160) | def _plot(self, split_gen, scales, orient):
    method _legend_artist (line 193) | def _legend_artist(self, variables, value, scales):
    method _setup_segments (line 210) | def _setup_segments(self, data, orient):
  class Lines (line 223) | class Lines(Paths):
  class Range (line 241) | class Range(Paths):
    method _setup_segments (line 250) | def _setup_segments(self, data, orient):
  class Dash (line 267) | class Dash(Paths):
    method _setup_segments (line 278) | def _setup_segments(self, data, orient):

FILE: seaborn/_marks/text.py
  class Text (line 23) | class Text(Mark):
    method _plot (line 40) | def _plot(self, split_gen, scales, orient):

FILE: seaborn/_statistics.py
  class KDE (line 42) | class KDE:
    method __init__ (line 44) | def __init__(
    method _define_support_grid (line 90) | def _define_support_grid(self, x, bw, cut, clip, gridsize):
    method _define_support_univariate (line 98) | def _define_support_univariate(self, x, weights):
    method _define_support_bivariate (line 107) | def _define_support_bivariate(self, x1, x2, weights):
    method define_support (line 125) | def define_support(self, x1, x2=None, weights=None, cache=True):
    method _fit (line 137) | def _fit(self, fit_data, weights=None):
    method _eval_univariate (line 148) | def _eval_univariate(self, x, weights=None):
    method _eval_bivariate (line 166) | def _eval_bivariate(self, x1, x2, weights=None):
    method __call__ (line 190) | def __call__(self, x1, x2=None, weights=None):
  class Histogram (line 200) | class Histogram:
    method __init__ (line 202) | def __init__(
    method _define_bin_edges (line 255) | def _define_bin_edges(self, x, weights, bins, binwidth, binrange, disc...
    method define_bin_params (line 276) | def define_bin_params(self, x1, x2=None, weights=None, cache=True):
    method _eval_bivariate (line 336) | def _eval_bivariate(self, x1, x2, weights):
    method _eval_univariate (line 368) | def _eval_univariate(self, x, weights):
    method __call__ (line 394) | def __call__(self, x1, x2=None, weights=None):
  class ECDF (line 402) | class ECDF:
    method __init__ (line 404) | def __init__(self, stat="proportion", complementary=False):
    method _eval_bivariate (line 419) | def _eval_bivariate(self, x1, x2, weights):
    method _eval_univariate (line 423) | def _eval_univariate(self, x, weights):
    method __call__ (line 443) | def __call__(self, x1, x2=None, weights=None):
  class EstimateAggregator (line 457) | class EstimateAggregator:
    method __init__ (line 459) | def __init__(self, estimator, errorbar=None, **boot_kws):
    method __call__ (line 484) | def __call__(self, data, var):
  class WeightedAggregator (line 523) | class WeightedAggregator:
    method __init__ (line 525) | def __init__(self, estimator, errorbar=None, **boot_kws):
    method __call__ (line 558) | def __call__(self, data, var):
  class LetterValues (line 579) | class LetterValues:
    method __init__ (line 581) | def __init__(self, k_depth, outlier_prop, trust_alpha):
    method _compute_k (line 619) | def _compute_k(self, n):
    method __call__ (line 640) | def __call__(self, x):
  function _percentile_interval (line 663) | def _percentile_interval(data, width):
  function _validate_errorbar_arg (line 670) | def _validate_errorbar_arg(arg):

FILE: seaborn/_stats/aggregation.py
  class Agg (line 19) | class Agg(Stat):
    method __call__ (line 41) | def __call__(
  class Est (line 56) | class Est(Stat):
    method _process (line 94) | def _process(
    method __call__ (line 102) | def __call__(
  class Rolling (line 126) | class Rolling(Stat):
    method __call__ (line 129) | def __call__(self, data, groupby, orient, scales):

FILE: seaborn/_stats/base.py
  class Stat (line 16) | class Stat:
    method _check_param_one_of (line 33) | def _check_param_one_of(self, param: str, options: Iterable[Any]) -> N...
    method _check_grouping_vars (line 45) | def _check_grouping_vars(
    method __call__ (line 57) | def __call__(

FILE: seaborn/_stats/counting.py
  class Count (line 19) | class Count(Stat):
    method __call__ (line 34) | def __call__(
  class Hist (line 49) | class Hist(Stat):
    method __post_init__ (line 116) | def __post_init__(self):
    method _define_bin_edges (line 123) | def _define_bin_edges(self, vals, weight, bins, binwidth, binrange, di...
    method _define_bin_params (line 143) | def _define_bin_params(self, data, orient, scale_type):
    method _get_bins_and_eval (line 165) | def _get_bins_and_eval(self, data, orient, groupby, scale_type):
    method _eval (line 170) | def _eval(self, data, orient, bin_kws):
    method _normalize (line 183) | def _normalize(self, data):
    method __call__ (line 201) | def __call__(

FILE: seaborn/_stats/density.py
  class KDE (line 22) | class KDE(Stat):
    method __post_init__ (line 94) | def __post_init__(self):
    method _check_var_list_or_boolean (line 99) | def _check_var_list_or_boolean(self, param: str, grouping_vars: Any) -...
    method _fit (line 110) | def _fit(self, data: DataFrame, orient: str) -> gaussian_kde:
    method _get_support (line 122) | def _get_support(self, data: DataFrame, orient: str) -> ndarray:
    method _fit_and_evaluate (line 133) | def _fit_and_evaluate(
    method _transform (line 154) | def _transform(
    method __call__ (line 172) | def __call__(

FILE: seaborn/_stats/order.py
  class Perc (line 38) | class Perc(Stat):
    method _percentile (line 62) | def _percentile(self, data: DataFrame, var: str) -> DataFrame:
    method __call__ (line 73) | def __call__(

FILE: seaborn/_stats/regression.py
  class PolyFit (line 11) | class PolyFit(Stat):
    method _fit_predict (line 22) | def _fit_predict(self, data):
    method __call__ (line 39) | def __call__(self, data, groupby, orient, scales):
  class OLSFit (line 48) | class OLSFit(Stat):

FILE: seaborn/_testing.py
  function assert_artists_equal (line 24) | def assert_artists_equal(list1, list2):
  function assert_legends_equal (line 50) | def assert_legends_equal(leg1, leg2):
  function assert_plots_equal (line 64) | def assert_plots_equal(ax1, ax2, labels=True):
  function assert_colors_equal (line 75) | def assert_colors_equal(a, b, check_alpha=True):

FILE: seaborn/algorithms.py
  function bootstrap (line 6) | def bootstrap(*args, **kwargs):
  function _structured_bootstrap (line 104) | def _structured_bootstrap(args, n_boot, units, func, func_kwargs, intege...

FILE: seaborn/axisgrid.py
  class _BaseGrid (line 37) | class _BaseGrid:
    method set (line 40) | def set(self, **kwargs):
    method fig (line 48) | def fig(self):
    method figure (line 57) | def figure(self):
    method apply (line 61) | def apply(self, func, *args, **kwargs):
    method pipe (line 76) | def pipe(self, func, *args, **kwargs):
    method savefig (line 90) | def savefig(self, *args, **kwargs):
  class Grid (line 103) | class Grid(_BaseGrid):
    method __init__ (line 108) | def __init__(self):
    method tight_layout (line 117) | def tight_layout(self, *args, **kwargs):
    method add_legend (line 126) | def add_legend(self, legend_data=None, title=None, label_order=None,
    method _update_legend_data (line 230) | def _update_legend_data(self, ax):
    method _get_palette (line 249) | def _get_palette(self, data, hue, hue_order, palette):
    method legend (line 280) | def legend(self):
    method tick_params (line 287) | def tick_params(self, axis='both', **kwargs):
  class FacetGrid (line 368) | class FacetGrid(Grid):
    method __init__ (line 371) | def __init__(
    method facet_data (line 643) | def facet_data(self):
    method map (line 683) | def map(self, func, *args, **kwargs):
    method map_dataframe (line 765) | def map_dataframe(self, func, *args, **kwargs):
    method _facet_color (line 836) | def _facet_color(self, hue_index, kw_color):
    method _facet_plot (line 844) | def _facet_plot(self, func, ax, plot_args, plot_kwargs):
    method _finalize_grid (line 859) | def _finalize_grid(self, axlabels):
    method facet_axis (line 864) | def facet_axis(self, row_i, col_j, modify_state=True):
    method despine (line 878) | def despine(self, **kwargs):
    method set_axis_labels (line 883) | def set_axis_labels(self, x_var=None, y_var=None, clear_inner=True, **...
    method set_xlabels (line 894) | def set_xlabels(self, label=None, clear_inner=True, **kwargs):
    method set_ylabels (line 905) | def set_ylabels(self, label=None, clear_inner=True, **kwargs):
    method set_xticklabels (line 916) | def set_xticklabels(self, labels=None, step=None, **kwargs):
    method set_yticklabels (line 932) | def set_yticklabels(self, labels=None, **kwargs):
    method set_titles (line 944) | def set_titles(self, template=None, row_template=None, col_template=No...
    method refline (line 1035) | def refline(self, *, x=None, y=None, color='.5', linestyle='--', **lin...
    method axes (line 1072) | def axes(self):
    method ax (line 1077) | def ax(self):
    method axes_dict (line 1088) | def axes_dict(self):
    method _inner_axes (line 1101) | def _inner_axes(self):
    method _left_axes (line 1119) | def _left_axes(self):
    method _not_left_axes (line 1131) | def _not_left_axes(self):
    method _bottom_axes (line 1143) | def _bottom_axes(self):
    method _not_bottom_axes (line 1160) | def _not_bottom_axes(self):
  class PairGrid (line 1177) | class PairGrid(Grid):
    method __init__ (line 1191) | def __init__(
    method map (line 1366) | def map(self, func, **kwargs):
    method map_lower (line 1383) | def map_lower(self, func, **kwargs):
    method map_upper (line 1398) | def map_upper(self, func, **kwargs):
    method map_offdiag (line 1413) | def map_offdiag(self, func, **kwargs):
    method map_diag (line 1437) | def map_diag(self, func, **kwargs):
    method _map_diag_iter_hue (line 1519) | def _map_diag_iter_hue(self, func, **kwargs):
    method _map_bivariate (line 1558) | def _map_bivariate(self, func, indices, **kwargs):
    method _plot_bivariate (line 1580) | def _plot_bivariate(self, x_var, y_var, ax, func, **kwargs):
    method _plot_bivariate_iter_hue (line 1619) | def _plot_bivariate_iter_hue(self, x_var, y_var, ax, func, **kwargs):
    method _add_axis_labels (line 1663) | def _add_axis_labels(self):
    method _find_numeric_cols (line 1670) | def _find_numeric_cols(self, data):
  class JointGrid (line 1679) | class JointGrid(_BaseGrid):
    method __init__ (line 1687) | def __init__(
    method _inject_kwargs (line 1769) | def _inject_kwargs(self, func, kws, params):
    method plot (line 1776) | def plot(self, joint_func, marginal_func, **kwargs):
    method plot_joint (line 1802) | def plot_joint(self, func, **kwargs):
    method plot_marginals (line 1838) | def plot_marginals(self, func, **kwargs):
    method refline (line 1899) | def refline(
    method set_axis_labels (line 1943) | def set_axis_labels(self, xlabel="", ylabel="", **kwargs):
  function pairplot (line 2010) | def pairplot(
  function jointplot (line 2184) | def jointplot(

FILE: seaborn/categorical.py
  class _CategoricalPlotter (line 49) | class _CategoricalPlotter(VectorPlotter):
    method __init__ (line 56) | def __init__(
    method _hue_backcompat (line 134) | def _hue_backcompat(self, color, palette, hue_order, force_hue=False):
    method _palette_without_hue_backcompat (line 187) | def _palette_without_hue_backcompat(self, palette, hue_order):
    method _point_kwargs_backcompat (line 207) | def _point_kwargs_backcompat(self, scale, join, kwargs):
    method _err_kws_backcompat (line 237) | def _err_kws_backcompat(self, err_kws, errcolor, errwidth, capsize):
    method _violin_scale_backcompat (line 264) | def _violin_scale_backcompat(self, scale, scale_hue, density_norm, com...
    method _violin_bw_backcompat (line 284) | def _violin_bw_backcompat(self, bw, bw_method):
    method _boxen_scale_backcompat (line 296) | def _boxen_scale_backcompat(self, scale, width_method):
    method _complement_color (line 312) | def _complement_color(self, color, base_color, hue_map):
    method _map_prop_with_hue (line 338) | def _map_prop_with_hue(self, name, value, fallback, plot_kws):
    method _adjust_cat_axis (line 354) | def _adjust_cat_axis(self, ax, axis):
    method _dodge_needed (line 385) | def _dodge_needed(self):
    method _dodge (line 394) | def _dodge(self, keys, data):
    method _invert_scale (line 409) | def _invert_scale(self, ax, data, vars=("x", "y")):
    method _configure_legend (line 421) | def _configure_legend(self, ax, func, common_kws=None, semantic_kws=No...
    method _native_width (line 433) | def _native_width(self):
    method _nested_offsets (line 447) | def _nested_offsets(self, width, dodge):
    method plot_strips (line 466) | def plot_strips(
    method plot_swarms (line 517) | def plot_swarms(
    method plot_boxes (line 591) | def plot_boxes(
    method plot_boxens (line 755) | def plot_boxens(
    method plot_violins (line 896) | def plot_violins(
    method plot_points (line 1172) | def plot_points(
    method plot_bars (line 1252) | def plot_bars(
    method plot_errorbars (line 1334) | def plot_errorbars(self, ax, data, capsize, err_kws):
  class _CategoricalAggPlotter (line 1363) | class _CategoricalAggPlotter(_CategoricalPlotter):
  function boxplot (line 1597) | def boxplot(
  function violinplot (line 1722) | def violinplot(
  function boxenplot (line 1912) | def boxenplot(
  function stripplot (line 2082) | def stripplot(
  function swarmplot (line 2207) | def swarmplot(
  function barplot (line 2336) | def barplot(
  function pointplot (line 2478) | def pointplot(
  function countplot (line 2627) | def countplot(
  function catplot (line 2761) | def catplot(
  class Beeswarm (line 3232) | class Beeswarm:
    method __init__ (line 3234) | def __init__(self, orient="x", width=0.8, warn_thresh=.05):
    method __call__ (line 3240) | def __call__(self, points, center):
    method beeswarm (line 3300) | def beeswarm(self, orig_xyr):
    method could_overlap (line 3332) | def could_overlap(self, xyr_i, swarm):
    method position_candidates (line 3346) | def position_candidates(self, xyr_i, neighbors):
    method first_non_overlapping_candidate (line 3363) | def first_non_overlapping_candidate(self, candidates, neighbors):
    method add_gutters (line 3396) | def add_gutters(self, points, center, trans_fwd, trans_inv):
  class BoxPlotContainer (line 3422) | class BoxPlotContainer:
    method __init__ (line 3424) | def __init__(self, artist_dict):
    method __repr__ (line 3443) | def __repr__(self):
    method __getitem__ (line 3446) | def __getitem__(self, idx):
    method __iter__ (line 3457) | def __iter__(self):
    method get_label (line 3460) | def get_label(self):
    method set_label (line 3463) | def set_label(self, value):
    method get_children (line 3466) | def get_children(self):
    method remove (line 3469) | def remove(self):

FILE: seaborn/distributions.py
  class _DistributionPlotter (line 99) | class _DistributionPlotter(VectorPlotter):
    method __init__ (line 104) | def __init__(
    method univariate (line 113) | def univariate(self):
    method data_variable (line 122) | def data_variable(self):
    method has_xy_data (line 130) | def has_xy_data(self):
    method _add_legend (line 135) | def _add_legend(
    method _artist_kws (line 170) | def _artist_kws(self, kws, fill, element, multiple, color, alpha):
    method _quantile_to_level (line 193) | def _quantile_to_level(self, data, quantile):
    method _cmap_from_color (line 203) | def _cmap_from_color(self, color):
    method _default_discrete (line 217) | def _default_discrete(self):
    method _resolve_multiple (line 227) | def _resolve_multiple(self, curves, multiple):
    method _compute_univariate_density (line 298) | def _compute_univariate_density(
    method plot_univariate_histogram (line 376) | def plot_univariate_histogram(
    method plot_bivariate_histogram (line 740) | def plot_bivariate_histogram(
    method plot_univariate_density (line 897) | def plot_univariate_density(
    method plot_bivariate_density (line 1028) | def plot_bivariate_density(
    method plot_univariate_ecdf (line 1210) | def plot_univariate_ecdf(self, estimate_kws, legend, **plot_kws):
    method plot_rug (line 1281) | def plot_rug(self, height, expand_margins, legend, **kws):
    method _plot_single_rug (line 1315) | def _plot_single_rug(self, sub_data, var, height, ax, kws):
  function histplot (line 1358) | def histplot(
  function kdeplot (line 1581) | def kdeplot(
  function ecdfplot (line 1861) | def ecdfplot(
  function rugplot (line 1973) | def rugplot(
  function displot (line 2094) | def displot(
  function _freedman_diaconis_bins (line 2375) | def _freedman_diaconis_bins(a):
  function distplot (line 2390) | def distplot(a=None, bins=None, hist=True, kde=True, rug=False, fit=None,

FILE: seaborn/external/appdirs.py
  function user_cache_dir (line 73) | def user_cache_dir(appname=None, appauthor=None, version=None, opinion=T...
  function _get_win_folder_from_registry (line 132) | def _get_win_folder_from_registry(csidl_name):
  function _get_win_folder_with_pywin32 (line 153) | def _get_win_folder_with_pywin32(csidl_name):
  function _get_win_folder_with_ctypes (line 180) | def _get_win_folder_with_ctypes(csidl_name):
  function _get_win_folder_with_jna (line 206) | def _get_win_folder_with_jna(csidl_name):

FILE: seaborn/external/docscrape.py
  function strip_blank_lines (line 40) | def strip_blank_lines(l):
  class Reader (line 49) | class Reader:
    method __init__ (line 53) | def __init__(self, data):
    method __getitem__ (line 68) | def __getitem__(self, n):
    method reset (line 71) | def reset(self):
    method read (line 74) | def read(self):
    method seek_next_non_empty_line (line 82) | def seek_next_non_empty_line(self):
    method eof (line 89) | def eof(self):
    method read_to_condition (line 92) | def read_to_condition(self, condition_func):
    method read_to_next_empty_line (line 102) | def read_to_next_empty_line(self):
    method read_to_next_unindented_line (line 110) | def read_to_next_unindented_line(self):
    method peek (line 115) | def peek(self, n=0):
    method is_empty (line 121) | def is_empty(self):
  class ParseError (line 125) | class ParseError(Exception):
    method __str__ (line 126) | def __str__(self):
  class NumpyDocString (line 136) | class NumpyDocString(Mapping):
    method __init__ (line 164) | def __init__(self, docstring, config={}):
    method __getitem__ (line 177) | def __getitem__(self, key):
    method __setitem__ (line 180) | def __setitem__(self, key, val):
    method __iter__ (line 186) | def __iter__(self):
    method __len__ (line 189) | def __len__(self):
    method _is_at_section (line 192) | def _is_at_section(self):
    method _strip (line 206) | def _strip(self, doc):
    method _read_to_next_section (line 219) | def _read_to_next_section(self):
    method _read_sections (line 230) | def _read_sections(self):
    method _parse_param_list (line 242) | def _parse_param_list(self, content, single_element_is_type=False):
    method _parse_see_also (line 299) | def _parse_see_also(self, content):
    method _parse_index (line 352) | def _parse_index(self, section, content):
    method _parse_summary (line 371) | def _parse_summary(self):
    method _parse (line 393) | def _parse(self):
    method _error_location (line 430) | def _error_location(self, msg, error=True):
    method _str_header (line 445) | def _str_header(self, name, symbol='-'):
    method _str_indent (line 448) | def _str_indent(self, doc, indent=4):
    method _str_signature (line 454) | def _str_signature(self):
    method _str_summary (line 460) | def _str_summary(self):
    method _str_extended_summary (line 466) | def _str_extended_summary(self):
    method _str_param_list (line 472) | def _str_param_list(self, name):
    method _str_section (line 488) | def _str_section(self, name):
    method _str_see_also (line 496) | def _str_see_also(self, func_role):
    method _str_index (line 528) | def _str_index(self):
    method __str__ (line 546) | def __str__(self, func_role=''):
  function indent (line 564) | def indent(str, indent=4):
  function dedent_lines (line 572) | def dedent_lines(lines):
  function header (line 577) | def header(text, style='-'):
  class FunctionDoc (line 581) | class FunctionDoc(NumpyDocString):
    method __init__ (line 582) | def __init__(self, func, role='func', doc=None, config={}):
    method get_func (line 609) | def get_func(self):
    method __str__ (line 617) | def __str__(self):
  class ClassDoc (line 634) | class ClassDoc(NumpyDocString):
    method __init__ (line 638) | def __init__(self, cls, doc=None, modulename='', func_doc=FunctionDoc,
    method methods (line 691) | def methods(self):
    method properties (line 701) | def properties(self):
    method _is_show_member (line 710) | def _is_show_member(self, name):

FILE: seaborn/external/husl.py
  function husl_to_rgb (line 31) | def husl_to_rgb(h, s, l):
  function husl_to_hex (line 35) | def husl_to_hex(h, s, l):
  function rgb_to_husl (line 39) | def rgb_to_husl(r, g, b):
  function hex_to_husl (line 43) | def hex_to_husl(hex):
  function huslp_to_rgb (line 47) | def huslp_to_rgb(h, s, l):
  function huslp_to_hex (line 51) | def huslp_to_hex(h, s, l):
  function rgb_to_huslp (line 55) | def rgb_to_huslp(r, g, b):
  function hex_to_huslp (line 59) | def hex_to_huslp(hex):
  function lch_to_rgb (line 63) | def lch_to_rgb(l, c, h):
  function rgb_to_lch (line 67) | def rgb_to_lch(r, g, b):
  function max_chroma (line 71) | def max_chroma(L, H):
  function _hrad_extremum (line 94) | def _hrad_extremum(L):
  function max_chroma_pastel (line 117) | def max_chroma_pastel(L):
  function dot_product (line 122) | def dot_product(a, b):
  function f (line 126) | def f(t):
  function f_inv (line 133) | def f_inv(t):
  function from_linear (line 140) | def from_linear(c):
  function to_linear (line 147) | def to_linear(c):
  function rgb_prepare (line 156) | def rgb_prepare(triple):
  function hex_to_rgb (line 178) | def hex_to_rgb(hex):
  function rgb_to_hex (line 187) | def rgb_to_hex(triple):
  function xyz_to_rgb (line 192) | def xyz_to_rgb(triple):
  function rgb_to_xyz (line 197) | def rgb_to_xyz(triple):
  function xyz_to_luv (line 202) | def xyz_to_luv(triple):
  function luv_to_xyz (line 222) | def luv_to_xyz(triple):
  function luv_to_lch (line 238) | def luv_to_lch(triple):
  function lch_to_luv (line 250) | def lch_to_luv(triple):
  function husl_to_lch (line 260) | def husl_to_lch(triple):
  function lch_to_husl (line 274) | def lch_to_husl(triple):
  function huslp_to_lch (line 288) | def huslp_to_lch(triple):
  function lch_to_huslp (line 302) | def lch_to_huslp(triple):

FILE: seaborn/external/kde.py
  class gaussian_kde (line 81) | class gaussian_kde:
    method __init__ (line 194) | def __init__(self, dataset, bw_method=None, weights=None):
    method evaluate (line 212) | def evaluate(self, points):
    method scotts_factor (line 270) | def scotts_factor(self):
    method silverman_factor (line 280) | def silverman_factor(self):
    method set_bandwidth (line 298) | def set_bandwidth(self, bw_method=None):
    method _compute_covariance (line 338) | def _compute_covariance(self):
    method pdf (line 354) | def pdf(self, x):
    method weights (line 367) | def weights(self):
    method neff (line 375) | def neff(self):

FILE: seaborn/external/version.py
  class InfinityType (line 34) | class InfinityType:
    method __repr__ (line 35) | def __repr__(self) -> str:
    method __hash__ (line 38) | def __hash__(self) -> int:
    method __lt__ (line 41) | def __lt__(self, other: object) -> bool:
    method __le__ (line 44) | def __le__(self, other: object) -> bool:
    method __eq__ (line 47) | def __eq__(self, other: object) -> bool:
    method __ne__ (line 50) | def __ne__(self, other: object) -> bool:
    method __gt__ (line 53) | def __gt__(self, other: object) -> bool:
    method __ge__ (line 56) | def __ge__(self, other: object) -> bool:
    method __neg__ (line 59) | def __neg__(self: object) -> "NegativeInfinityType":
  class NegativeInfinityType (line 66) | class NegativeInfinityType:
    method __repr__ (line 67) | def __repr__(self) -> str:
    method __hash__ (line 70) | def __hash__(self) -> int:
    method __lt__ (line 73) | def __lt__(self, other: object) -> bool:
    method __le__ (line 76) | def __le__(self, other: object) -> bool:
    method __eq__ (line 79) | def __eq__(self, other: object) -> bool:
    method __ne__ (line 82) | def __ne__(self, other: object) -> bool:
    method __gt__ (line 85) | def __gt__(self, other: object) -> bool:
    method __ge__ (line 88) | def __ge__(self, other: object) -> bool:
    method __neg__ (line 91) | def __neg__(self: object) -> InfinityType:
  class InvalidVersion (line 128) | class InvalidVersion(ValueError):
  class _BaseVersion (line 134) | class _BaseVersion:
    method __hash__ (line 137) | def __hash__(self) -> int:
    method __lt__ (line 143) | def __lt__(self, other: "_BaseVersion") -> bool:
    method __le__ (line 149) | def __le__(self, other: "_BaseVersion") -> bool:
    method __eq__ (line 155) | def __eq__(self, other: object) -> bool:
    method __ge__ (line 161) | def __ge__(self, other: "_BaseVersion") -> bool:
    method __gt__ (line 167) | def __gt__(self, other: "_BaseVersion") -> bool:
    method __ne__ (line 173) | def __ne__(self, other: object) -> bool:
  class Version (line 214) | class Version(_BaseVersion):
    method __init__ (line 218) | def __init__(self, version: str) -> None:
    method __repr__ (line 247) | def __repr__(self) -> str:
    method __str__ (line 250) | def __str__(self) -> str:
    method epoch (line 279) | def epoch(self) -> int:
    method release (line 284) | def release(self) -> Tuple[int, ...]:
    method pre (line 289) | def pre(self) -> Optional[Tuple[str, int]]:
    method post (line 294) | def post(self) -> Optional[int]:
    method dev (line 298) | def dev(self) -> Optional[int]:
    method local (line 302) | def local(self) -> Optional[str]:
    method public (line 309) | def public(self) -> str:
    method base_version (line 313) | def base_version(self) -> str:
    method is_prerelease (line 326) | def is_prerelease(self) -> bool:
    method is_postrelease (line 330) | def is_postrelease(self) -> bool:
    method is_devrelease (line 334) | def is_devrelease(self) -> bool:
    method major (line 338) | def major(self) -> int:
    method minor (line 342) | def minor(self) -> int:
    method micro (line 346) | def micro(self) -> int:
  function _parse_letter_version (line 350) | def _parse_letter_version(
  function _parse_local_version (line 389) | def _parse_local_version(local: str) -> Optional[LocalType]:
  function _cmpkey (line 401) | def _cmpkey(

FILE: seaborn/matrix.py
  function _index_to_label (line 31) | def _index_to_label(index):
  function _index_to_ticklabels (line 39) | def _index_to_ticklabels(index):
  function _convert_colors (line 47) | def _convert_colors(colors):
  function _matrix_mask (line 60) | def _matrix_mask(data, mask):
  class _HeatMapper (line 97) | class _HeatMapper:
    method __init__ (line 100) | def __init__(self, data, vmin, vmax, cmap, center, robust, annot, fmt,
    method _determine_cmap_params (line 192) | def _determine_cmap_params(self, plot_data, vmin, vmax,
    method _annotate_heatmap (line 249) | def _annotate_heatmap(self, ax, mesh):
    method _skip_ticks (line 265) | def _skip_ticks(self, labels, tickevery):
    method _auto_ticks (line 278) | def _auto_ticks(self, ax, labels, axis):
    method plot (line 294) | def plot(self, ax, cax, kws):
  function heatmap (line 355) | def heatmap(
  class _DendrogramPlotter (line 463) | class _DendrogramPlotter:
    method __init__ (line 466) | def __init__(self, data, linkage, metric, method, axis, label, rotate):
    method _calculate_linkage_scipy (line 529) | def _calculate_linkage_scipy(self):
    method _calculate_linkage_fastcluster (line 534) | def _calculate_linkage_fastcluster(self):
    method calculated_linkage (line 552) | def calculated_linkage(self):
    method calculate_dendrogram (line 564) | def calculate_dendrogram(self):
    method reordered_ind (line 581) | def reordered_ind(self):
    method plot (line 585) | def plot(self, ax, tree_kws):
  function dendrogram (line 642) | def dendrogram(
  class ClusterGrid (line 696) | class ClusterGrid(Grid):
    method __init__ (line 698) | def __init__(self, data, pivot_kws=None, z_score=None, standard_scale=...
    method _preprocess_colors (line 774) | def _preprocess_colors(self, data, colors, axis):
    method format_data (line 816) | def format_data(self, data, pivot_kws, z_score=None,
    method z_score (line 837) | def z_score(data2d, axis=1):
    method standard_scale (line 867) | def standard_scale(data2d, axis=1):
    method dim_ratios (line 900) | def dim_ratios(self, colors, dendrogram_ratio, colors_ratio):
    method color_list_to_matrix_and_cmap (line 919) | def color_list_to_matrix_and_cmap(colors, ind, axis=0):
    method plot_dendrograms (line 970) | def plot_dendrograms(self, row_cluster, col_cluster, metric, method,
    method plot_colors (line 995) | def plot_colors(self, xind, yind, **kws):
    method plot_matrix (line 1060) | def plot_matrix(self, colorbar_kws, xind, yind, **kws):
    method plot (line 1117) | def plot(self, metric, method, colorbar_kws, row_cluster, col_cluster,
  function clustermap (line 1146) | def clustermap(

FILE: seaborn/miscplot.py
  function palplot (line 9) | def palplot(pal, size=1):
  function dogplot (line 33) | def dogplot(*_, **__):

FILE: seaborn/palettes.py
  class _ColorPalette (line 61) | class _ColorPalette(list):
    method __enter__ (line 63) | def __enter__(self):
    method __exit__ (line 70) | def __exit__(self, *args):
    method as_hex (line 75) | def as_hex(self):
    method _repr_html_ (line 80) | def _repr_html_(self):
  function _patch_colormap_display (line 94) | def _patch_colormap_display():
  function color_palette (line 122) | def color_palette(palette=None, n_colors=None, desat=None, as_cmap=False):
  function hls_palette (line 258) | def hls_palette(n_colors=6, h=.01, l=.6, s=.65, as_cmap=False):  # noqa
  function husl_palette (line 312) | def husl_palette(n_colors=6, h=.01, s=.9, l=.65, as_cmap=False):  # noqa
  function mpl_palette (line 366) | def mpl_palette(name, n_colors=6, as_cmap=False):
  function _color_to_rgb (line 420) | def _color_to_rgb(color, input):
  function dark_palette (line 433) | def dark_palette(color, n_colors=6, reverse=False, as_cmap=False, input=...
  function light_palette (line 484) | def light_palette(color, n_colors=6, reverse=False, as_cmap=False, input...
  function diverging_palette (line 532) | def diverging_palette(h_neg, h_pos, s=75, l=50, sep=1, n=6,  # noqa
  function blend_palette (line 581) | def blend_palette(colors, n_colors=6, as_cmap=False, input="rgb"):
  function xkcd_palette (line 612) | def xkcd_palette(colors):
  function crayon_palette (line 638) | def crayon_palette(colors):
  function cubehelix_palette (line 665) | def cubehelix_palette(n_colors=6, start=0, rot=.4, gamma=1.0, hue=0.8,
  function _parse_cubehelix_args (line 764) | def _parse_cubehelix_args(argstr):
  function set_color_codes (line 799) | def set_color_codes(palette="deep"):

FILE: seaborn/rcmod.py
  function set_theme (line 82) | def set_theme(context="notebook", style="darkgrid", palette="deep",
  function set (line 126) | def set(*args, **kwargs):
  function reset_defaults (line 135) | def reset_defaults():
  function reset_orig (line 140) | def reset_orig():
  function axes_style (line 146) | def axes_style(style=None, rc=None):
  function set_style (line 303) | def set_style(style=None, rc=None):
  function plotting_context (line 335) | def plotting_context(context=None, font_scale=1, rc=None):
  function set_context (line 435) | def set_context(context=None, font_scale=1, rc=None):
  class _RCAesthetics (line 472) | class _RCAesthetics(dict):
    method __enter__ (line 473) | def __enter__(self):
    method __exit__ (line 478) | def __exit__(self, exc_type, exc_value, exc_tb):
    method __call__ (line 481) | def __call__(self, func):
  class _AxesStyle (line 489) | class _AxesStyle(_RCAesthetics):
  class _PlottingContext (line 495) | class _PlottingContext(_RCAesthetics):
  function set_palette (line 501) | def set_palette(palette, n_colors=None, desat=None, color_codes=False):

FILE: seaborn/regression.py
  class _LinearPlotter (line 25) | class _LinearPlotter:
    method establish_variables (line 32) | def establish_variables(self, data, **kws):
    method dropna (line 56) | def dropna(self, *vars):
    method plot (line 66) | def plot(self, ax):
  class _RegressionPlotter (line 70) | class _RegressionPlotter(_LinearPlotter):
    method __init__ (line 76) | def __init__(self, x, y, data=None, x_estimator=None, x_bins=None,
    method scatter_data (line 137) | def scatter_data(self):
    method estimate_data (line 154) | def estimate_data(self):
    method _check_statsmodels (line 188) | def _check_statsmodels(self):
    method fit_regression (line 196) | def fit_regression(self, ax=None, x_range=None, grid=None):
    method fit_fast (line 239) | def fit_fast(self, grid):
    method fit_poly (line 258) | def fit_poly(self, grid, order):
    method fit_statsmodels (line 275) | def fit_statsmodels(self, grid, model, **kwargs):
    method fit_lowess (line 306) | def fit_lowess(self):
    method fit_logx (line 312) | def fit_logx(self, grid):
    method bin_predictor (line 333) | def bin_predictor(self, bins):
    method regress_out (line 347) | def regress_out(self, a, b):
    method plot (line 356) | def plot(self, ax, scatter_kws, line_kws):
    method scatterplot (line 392) | def scatterplot(self, ax, kws):
    method lineplot (line 426) | def lineplot(self, ax, kws):
  function lmplot (line 580) | def lmplot(
  function regplot (line 761) | def regplot(
  function residplot (line 864) | def residplot(

FILE: seaborn/relational.py
  class _RelationalPlotter (line 188) | class _RelationalPlotter(VectorPlotter):
  class _LinePlotter (line 198) | class _LinePlotter(_RelationalPlotter):
    method __init__ (line 202) | def __init__(
    method plot (line 229) | def plot(self, ax, kws):
  class _ScatterPlotter (line 383) | class _ScatterPlotter(_RelationalPlotter):
    method __init__ (line 387) | def __init__(self, *, data=None, variables={}, legend=None):
    method plot (line 400) | def plot(self, ax, kws):
  function lineplot (line 471) | def lineplot(
  function scatterplot (line 606) | def scatterplot(
  function relplot (line 700) | def relplot(

FILE: seaborn/utils.py
  function ci_to_errsize (line 28) | def ci_to_errsize(cis, heights):
  function _draw_figure (line 58) | def _draw_figure(fig):
  function _default_color (line 69) | def _default_color(method, hue, color, kws, saturation=1):
  function desaturate (line 147) | def desaturate(color, prop):
  function saturate (line 186) | def saturate(color):
  function set_hls_values (line 203) | def set_hls_values(color, h=None, l=None, s=None):  # noqa
  function axlabel (line 230) | def axlabel(xlabel, ylabel, **kwargs):
  function remove_na (line 243) | def remove_na(vector):
  function get_color_cycle (line 260) | def get_color_cycle():
  function despine (line 277) | def despine(fig=None, ax=None, top=True, right=True, left=False,
  function move_legend (line 379) | def move_legend(obj, loc, **kwargs):
  function _kde_support (line 478) | def _kde_support(data, bw, gridsize, cut, clip):
  function ci (line 487) | def ci(a, which=95, axis=None):
  function get_dataset_names (line 493) | def get_dataset_names():
  function get_data_home (line 506) | def get_data_home(data_home=None):
  function load_dataset (line 524) | def load_dataset(name, cache=True, data_home=None, **kws):
  function axis_ticklabels_overlap (line 632) | def axis_ticklabels_overlap(labels):
  function axes_ticklabels_overlap (line 656) | def axes_ticklabels_overlap(ax):
  function locator_to_legend_entries (line 673) | def locator_to_legend_entries(locator, limits, dtype):
  function relative_luminance (line 699) | def relative_luminance(color):
  function to_utf8 (line 721) | def to_utf8(obj):
  function _check_argument (line 750) | def _check_argument(param, options, value, prefix=False):
  function _assign_default_kwargs (line 764) | def _assign_default_kwargs(kws, call_func, source_func):
  function adjust_legend_subtitles (line 783) | def adjust_legend_subtitles(legend):
  function _deprecate_ci (line 803) | def _deprecate_ci(errorbar, ci):
  function _get_transform_functions (line 828) | def _get_transform_functions(ax, axis):
  function _disable_autolayout (line 836) | def _disable_autolayout():
  function _version_predates (line 854) | def _version_predates(lib: ModuleType, version: str) -> bool:
  function _scatter_legend_artist (line 859) | def _scatter_legend_artist(**kws):
  function _get_patch_legend_artist (line 883) | def _get_patch_legend_artist(fill):

FILE: seaborn/widgets.py
  function interact (line 8) | def interact(f):
  function _init_mutable_colormap (line 22) | def _init_mutable_colormap():
  function _update_lut (line 31) | def _update_lut(cmap, colors):
  function _show_cmap (line 37) | def _show_cmap(cmap):
  function choose_colorbrewer_palette (line 47) | def choose_colorbrewer_palette(data_type, as_cmap=False):
  function choose_dark_palette (line 143) | def choose_dark_palette(input="husl", as_cmap=False):
  function choose_light_palette (line 228) | def choose_light_palette(input="husl", as_cmap=False):
  function choose_diverging_palette (line 313) | def choose_diverging_palette(as_cmap=False):
  function choose_cubehelix_palette (line 372) | def choose_cubehelix_palette(as_cmap=False):

FILE: tests/_core/test_data.py
  class TestPlotData (line 15) | class TestPlotData:
    method long_variables (line 18) | def long_variables(self):
    method test_named_vectors (line 22) | def test_named_vectors(self, long_df, long_variables):
    method test_named_and_given_vectors (line 31) | def test_named_and_given_vectors(self, long_df, long_variables):
    method test_index_as_variable (line 50) | def test_index_as_variable(self, long_df, long_variables):
    method test_multiindex_as_variables (line 59) | def test_multiindex_as_variables(self, long_df, long_variables):
    method test_int_as_variable_key (line 70) | def test_int_as_variable_key(self, rng):
    method test_int_as_variable_value (line 81) | def test_int_as_variable_value(self, long_df):
    method test_tuple_as_variable_key (line 88) | def test_tuple_as_variable_key(self, rng):
    method test_dict_as_data (line 99) | def test_dict_as_data(self, long_dict, long_variables):
    method test_vectors_various_types (line 110) | def test_vectors_various_types(self, long_df, long_variables, vector_t...
    method test_none_as_variable_value (line 134) | def test_none_as_variable_value(self, long_df):
    method test_frame_and_vector_mismatched_lengths (line 140) | def test_frame_and_vector_mismatched_lengths(self, long_df):
    method test_empty_data_input (line 149) | def test_empty_data_input(self, arg):
    method test_index_alignment_series_to_dataframe (line 160) | def test_index_alignment_series_to_dataframe(self):
    method test_index_alignment_between_series (line 178) | def test_index_alignment_between_series(self):
    method test_key_not_in_data_raises (line 196) | def test_key_not_in_data_raises(self, long_df):
    method test_key_with_no_data_raises (line 204) | def test_key_with_no_data_raises(self):
    method test_data_vector_different_lengths_raises (line 212) | def test_data_vector_different_lengths_raises(self, long_df):
    method test_undefined_variables_raise (line 219) | def test_undefined_variables_raise(self, long_df):
    method test_contains_operation (line 230) | def test_contains_operation(self, long_df):
    method test_join_add_variable (line 237) | def test_join_add_variable(self, long_df):
    method test_join_replace_variable (line 250) | def test_join_replace_variable(self, long_df):
    method test_join_remove_variable (line 266) | def test_join_remove_variable(self, long_df):
    method test_join_all_operations (line 279) | def test_join_all_operations(self, long_df):
    method test_join_all_operations_same_data (line 294) | def test_join_all_operations_same_data(self, long_df):
    method test_join_add_variable_new_data (line 309) | def test_join_add_variable_new_data(self, long_df):
    method test_join_replace_variable_new_data (line 324) | def test_join_replace_variable_new_data(self, long_df):
    method test_join_add_variable_different_index (line 342) | def test_join_add_variable_different_index(self, long_df):
    method test_join_replace_variable_different_index (line 362) | def test_join_replace_variable_different_index(self, long_df):
    method test_join_subset_data_inherit_variables (line 381) | def test_join_subset_data_inherit_variables(self, long_df):
    method test_join_multiple_inherits_from_orig (line 392) | def test_join_multiple_inherits_from_orig(self, rng):
    method test_bad_type (line 401) | def test_bad_type(self, flat_list):
    method test_data_interchange (line 411) | def test_data_interchange(self, mock_long_df, long_df):
    method test_data_interchange_failure (line 422) | def test_data_interchange_failure(self, mock_long_df):
    method test_data_interchange_support_test (line 432) | def test_data_interchange_support_test(self, mock_long_df):

FILE: tests/_core/test_groupby.py
  function df (line 12) | def df():
  function test_init_from_list (line 26) | def test_init_from_list():
  function test_init_from_dict (line 31) | def test_init_from_dict():
  function test_init_requires_order (line 37) | def test_init_requires_order():
  function test_at_least_one_grouping_variable_required (line 43) | def test_at_least_one_grouping_variable_required(df):
  function test_agg_one_grouper (line 49) | def test_agg_one_grouper(df):
  function test_agg_two_groupers (line 58) | def test_agg_two_groupers(df):
  function test_agg_two_groupers_ordered (line 68) | def test_agg_two_groupers_ordered(df):
  function test_apply_no_grouper (line 83) | def test_apply_no_grouper(df):
  function test_apply_one_grouper (line 92) | def test_apply_one_grouper(df):
  function test_apply_mutate_columns (line 102) | def test_apply_mutate_columns(df):
  function test_apply_replace_columns (line 121) | def test_apply_replace_columns(df):

FILE: tests/_core/test_moves.py
  class MoveFixtures (line 16) | class MoveFixtures:
    method df (line 19) | def df(self, rng):
    method toy_df (line 33) | def toy_df(self):
    method toy_df_widths (line 45) | def toy_df_widths(self, toy_df):
    method toy_df_facets (line 51) | def toy_df_facets(self):
  class TestJitter (line 64) | class TestJitter(MoveFixtures):
    method get_groupby (line 66) | def get_groupby(self, data, orient):
    method check_same (line 71) | def check_same(self, res, df, *cols):
    method check_pos (line 75) | def check_pos(self, res, df, var, limit):
    method test_default (line 81) | def test_default(self, df):
    method test_width (line 90) | def test_width(self, df):
    method test_x (line 99) | def test_x(self, df):
    method test_y (line 108) | def test_y(self, df):
    method test_seed (line 117) | def test_seed(self, df):
  class TestDodge (line 128) | class TestDodge(MoveFixtures):
    method test_default (line 132) | def test_default(self, toy_df):
    method test_fill (line 141) | def test_fill(self, toy_df):
    method test_drop (line 150) | def test_drop(self, toy_df):
    method test_gap (line 159) | def test_gap(self, toy_df):
    method test_widths_default (line 168) | def test_widths_default(self, toy_df_widths):
    method test_widths_fill (line 177) | def test_widths_fill(self, toy_df_widths):
    method test_widths_drop (line 186) | def test_widths_drop(self, toy_df_widths):
    method test_faceted_default (line 195) | def test_faceted_default(self, toy_df_facets):
    method test_faceted_fill (line 204) | def test_faceted_fill(self, toy_df_facets):
    method test_faceted_drop (line 213) | def test_faceted_drop(self, toy_df_facets):
    method test_orient (line 222) | def test_orient(self, toy_df):
    method test_single_semantic (line 236) | def test_single_semantic(self, df, grp):
    method test_two_semantics (line 254) | def test_two_semantics(self, df):
  class TestStack (line 273) | class TestStack(MoveFixtures):
    method test_basic (line 275) | def test_basic(self, toy_df):
    method test_faceted (line 284) | def test_faceted(self, toy_df_facets):
    method test_misssing_data (line 293) | def test_misssing_data(self, toy_df):
    method test_baseline_homogeneity_check (line 304) | def test_baseline_homogeneity_check(self, toy_df):
  class TestShift (line 314) | class TestShift(MoveFixtures):
    method test_default (line 316) | def test_default(self, toy_df):
    method test_moves (line 324) | def test_moves(self, toy_df, x, y):
  class TestNorm (line 332) | class TestNorm(MoveFixtures):
    method test_default_no_groups (line 335) | def test_default_no_groups(self, df, orient):
    method test_default_groups (line 343) | def test_default_groups(self, df, orient):
    method test_sum (line 351) | def test_sum(self, df):
    method test_where (line 357) | def test_where(self, df):
    method test_percent (line 363) | def test_percent(self, df):

FILE: tests/_core/test_plot.py
  function assert_gridspec_shape (line 36) | def assert_gridspec_shape(ax, nrows=1, ncols=1):
  class MockMark (line 43) | class MockMark(Mark):
    method __init__ (line 47) | def __init__(self, *args, **kwargs):
    method _plot (line 57) | def _plot(self, split_gen, scales, orient):
    method _legend_artist (line 68) | def _legend_artist(self, variables, value, scales):
  class TestInit (line 76) | class TestInit:
    method test_empty (line 78) | def test_empty(self):
    method test_data_only (line 84) | def test_data_only(self, long_df):
    method test_df_and_named_variables (line 90) | def test_df_and_named_variables(self, long_df):
    method test_df_and_mixed_variables (line 99) | def test_df_and_mixed_variables(self, long_df):
    method test_vector_variables_only (line 111) | def test_vector_variables_only(self, long_df):
    method test_vector_variables_no_index (line 120) | def test_vector_variables_no_index(self, long_df):
    method test_data_only_named (line 130) | def test_data_only_named(self, long_df):
    method test_positional_and_named_data (line 136) | def test_positional_and_named_data(self, long_df):
    method test_positional_and_named_xy (line 143) | def test_positional_and_named_xy(self, long_df, var):
    method test_positional_data_x_y (line 149) | def test_positional_data_x_y(self, long_df):
    method test_positional_x_y (line 155) | def test_positional_x_y(self, long_df):
    method test_positional_data_x (line 161) | def test_positional_data_x(self, long_df):
    method test_positional_x (line 167) | def test_positional_x(self, long_df):
    method test_positional_interchangeable_dataframe (line 177) | def test_positional_interchangeable_dataframe(self, mock_long_df, long...
    method test_positional_too_many (line 182) | def test_positional_too_many(self, long_df):
    method test_unknown_keywords (line 188) | def test_unknown_keywords(self, long_df):
  class TestLayerAddition (line 195) | class TestLayerAddition:
    method test_without_data (line 197) | def test_without_data(self, long_df):
    method test_with_new_variable_by_name (line 203) | def test_with_new_variable_by_name(self, long_df):
    method test_with_new_variable_by_vector (line 211) | def test_with_new_variable_by_vector(self, long_df):
    method test_with_late_data_definition (line 219) | def test_with_late_data_definition(self, long_df):
    method test_with_new_data_definition (line 227) | def test_with_new_data_definition(self, long_df):
    method test_drop_variable (line 239) | def test_drop_variable(self, long_df):
    method test_stat_default (line 247) | def test_stat_default(self):
    method test_stat_nondefault (line 256) | def test_stat_nondefault(self):
    method test_orient (line 272) | def test_orient(self, arg, expected):
    method test_variable_list (line 291) | def test_variable_list(self, long_df):
    method test_type_checks (line 315) | def test_type_checks(self):
  class TestScaling (line 339) | class TestScaling:
    method test_inference (line 341) | def test_inference(self, long_df):
    method test_inference_from_layer_data (line 348) | def test_inference_from_layer_data(self):
    method test_inference_joins (line 353) | def test_inference_joins(self):
    method test_inferred_categorical_converter (line 363) | def test_inferred_categorical_converter(self):
    method test_explicit_categorical_converter (line 369) | def test_explicit_categorical_converter(self):
    method test_categorical_as_datetime (line 376) | def test_categorical_as_datetime(self):
    method test_faceted_log_scale (line 383) | def test_faceted_log_scale(self):
    method test_paired_single_log_scale (line 390) | def test_paired_single_log_scale(self):
    method test_paired_with_common_fallback (line 400) | def test_paired_with_common_fallback(self):
    method test_log_scale_name (line 411) | def test_log_scale_name(self):
    method test_mark_data_log_transform_is_inverted (line 418) | def test_mark_data_log_transform_is_inverted(self, long_df):
    method test_mark_data_log_transfrom_with_stat (line 425) | def test_mark_data_log_transfrom_with_stat(self, long_df):
    method test_mark_data_from_categorical (line 451) | def test_mark_data_from_categorical(self, long_df):
    method test_mark_data_from_datetime (line 461) | def test_mark_data_from_datetime(self, long_df):
    method test_computed_var_ticks (line 470) | def test_computed_var_ticks(self, long_df):
    method test_computed_var_transform (line 483) | def test_computed_var_transform(self, long_df):
    method test_explicit_range_with_axis_scaling (line 495) | def test_explicit_range_with_axis_scaling(self):
    method test_derived_range_with_axis_scaling (line 504) | def test_derived_range_with_axis_scaling(self):
    method test_facet_categories (line 516) | def test_facet_categories(self):
    method test_facet_categories_unshared (line 526) | def test_facet_categories_unshared(self):
    method test_facet_categories_single_dim_shared (line 542) | def test_facet_categories_single_dim_shared(self):
    method test_pair_categories (line 569) | def test_pair_categories(self):
    method test_pair_categories_shared (line 582) | def test_pair_categories_shared(self):
    method test_identity_mapping_linewidth (line 595) | def test_identity_mapping_linewidth(self):
    method test_pair_single_coordinate_stat_orient (line 603) | def test_pair_single_coordinate_stat_orient(self, long_df):
    method test_inferred_nominal_passed_to_stat (line 614) | def test_inferred_nominal_passed_to_stat(self):
    method test_identity_mapping_color_strings (line 630) | def test_identity_mapping_color_strings(self):
    method test_identity_mapping_color_tuples (line 639) | def test_identity_mapping_color_tuples(self):
    method test_undefined_variable_raises (line 651) | def test_undefined_variable_raises(self):
    method test_nominal_x_axis_tweaks (line 658) | def test_nominal_x_axis_tweaks(self):
    method test_nominal_y_axis_tweaks (line 669) | def test_nominal_y_axis_tweaks(self):
  class TestPlotting (line 681) | class TestPlotting:
    method test_matplotlib_object_creation (line 683) | def test_matplotlib_object_creation(self):
    method test_empty (line 690) | def test_empty(self):
    method test_no_orient_variance (line 697) | def test_no_orient_variance(self):
    method test_single_split_single_layer (line 705) | def test_single_split_single_layer(self, long_df):
    method test_single_split_multi_layer (line 716) | def test_single_split_multi_layer(self, long_df):
    method check_splits_single_var (line 730) | def check_splits_single_var(
    method check_splits_multi_vars (line 743) | def check_splits_multi_vars(
    method test_one_grouping_variable (line 769) | def test_one_grouping_variable(self, long_df, split_var):
    method test_two_grouping_variables (line 784) | def test_two_grouping_variables(self, long_df):
    method test_specified_width (line 802) | def test_specified_width(self, long_df):
    method test_facets_no_subgroups (line 808) | def test_facets_no_subgroups(self, long_df):
    method test_facets_one_subgroup (line 823) | def test_facets_one_subgroup(self, long_df):
    method test_layer_specific_facet_disabling (line 848) | def test_layer_specific_facet_disabling(self, long_df):
    method test_paired_variables (line 863) | def test_paired_variables(self, long_df):
    method test_paired_one_dimension (line 877) | def test_paired_one_dimension(self, long_df):
    method test_paired_variables_one_subset (line 887) | def test_paired_variables_one_subset(self, long_df):
    method test_paired_and_faceted (line 906) | def test_paired_and_faceted(self, long_df):
    method test_theme_default (line 923) | def test_theme_default(self):
    method test_theme_params (line 928) | def test_theme_params(self):
    method test_theme_error (line 934) | def test_theme_error(self):
    method test_theme_validation (line 940) | def test_theme_validation(self):
    method test_stat (line 950) | def test_stat(self, long_df):
    method test_move (line 962) | def test_move(self, long_df):
    method test_stat_and_move (line 973) | def test_stat_and_move(self, long_df):
    method test_stat_log_scale (line 981) | def test_stat_log_scale(self, long_df):
    method test_move_log_scale (line 995) | def test_move_log_scale(self, long_df):
    method test_multi_move (line 1003) | def test_multi_move(self, long_df):
    method test_multi_move_with_pairing (line 1010) | def test_multi_move_with_pairing(self, long_df):
    method test_move_with_range (line 1017) | def test_move_with_range(self, long_df):
    method test_methods_clone (line 1031) | def test_methods_clone(self, long_df):
    method test_default_is_no_pyplot (line 1040) | def test_default_is_no_pyplot(self):
    method test_with_pyplot (line 1047) | def test_with_pyplot(self):
    method test_show (line 1055) | def test_show(self):
    method test_save (line 1074) | def test_save(self):
    method test_layout_size (line 1088) | def test_layout_size(self):
    method test_layout_extent (line 1098) | def test_layout_extent(self):
    method test_constrained_layout_extent (line 1107) | def test_constrained_layout_extent(self):
    method test_base_layout_extent (line 1112) | def test_base_layout_extent(self):
    method test_on_axes (line 1120) | def test_on_axes(self):
    method test_on_figure (line 1129) | def test_on_figure(self, facet):
    method test_on_subfigure (line 1141) | def test_on_subfigure(self, facet):
    method test_on_type_check (line 1153) | def test_on_type_check(self):
    method test_on_axes_with_subplots_error (line 1159) | def test_on_axes_with_subplots_error(self):
    method test_on_layout_algo_default (line 1175) | def test_on_layout_algo_default(self):
    method test_on_layout_algo_spec (line 1189) | def test_on_layout_algo_spec(self):
    method test_axis_labels_from_constructor (line 1196) | def test_axis_labels_from_constructor(self, long_df):
    method test_axis_labels_from_layer (line 1206) | def test_axis_labels_from_layer(self, long_df):
    method test_axis_labels_are_first_name (line 1219) | def test_axis_labels_are_first_name(self, long_df):
    method test_limits (line 1231) | def test_limits(self, long_df):
    method test_labels_axis (line 1248) | def test_labels_axis(self, long_df):
    method test_labels_legend (line 1260) | def test_labels_legend(self, long_df):
    method test_labels_facets (line 1272) | def test_labels_facets(self):
    method test_title_single (line 1281) | def test_title_single(self):
    method test_title_facet_function (line 1287) | def test_title_facet_function(self):
  class TestExceptions (line 1301) | class TestExceptions:
    method test_scale_setup (line 1303) | def test_scale_setup(self):
    method test_coordinate_scaling (line 1315) | def test_coordinate_scaling(self):
    method test_semantic_scaling (line 1327) | def test_semantic_scaling(self):
  class TestFacetInterface (line 1349) | class TestFacetInterface:
    method dim (line 1352) | def dim(self, request):
    method reorder (line 1356) | def reorder(self, request):
    method check_facet_results_1d (line 1363) | def check_facet_results_1d(self, p, df, dim, key, order=None):
    method test_1d (line 1378) | def test_1d(self, long_df, dim):
    method test_1d_as_vector (line 1384) | def test_1d_as_vector(self, long_df, dim):
    method test_1d_with_order (line 1390) | def test_1d_with_order(self, long_df, dim, reorder):
    method check_facet_results_2d (line 1397) | def check_facet_results_2d(self, p, df, variables, order=None):
    method test_2d (line 1417) | def test_2d(self, long_df):
    method test_2d_with_order (line 1423) | def test_2d_with_order(self, long_df, reorder):
    method test_layout_algo (line 1435) | def test_layout_algo(self, algo):
    method test_axis_sharing (line 1453) | def test_axis_sharing(self, long_df):
    method test_unshared_spacing (line 1488) | def test_unshared_spacing(self):
    method test_col_wrapping (line 1499) | def test_col_wrapping(self):
    method test_row_wrapping (line 1510) | def test_row_wrapping(self):
  class TestPairInterface (line 1522) | class TestPairInterface:
    method check_pair_grid (line 1524) | def check_pair_grid(self, p, x, y):
    method test_all_numeric (line 1536) | def test_all_numeric(self, long_df, vector_type):
    method test_single_variable_key_raises (line 1542) | def test_single_variable_key_raises(self, long_df):
    method test_single_dimension (line 1550) | def test_single_dimension(self, long_df, dim):
    method test_non_cross (line 1558) | def test_non_cross(self, long_df):
    method test_list_of_vectors (line 1576) | def test_list_of_vectors(self, long_df):
    method test_with_no_variables (line 1584) | def test_with_no_variables(self, long_df):
    method test_with_facets (line 1589) | def test_with_facets(self, long_df):
    method test_error_on_facet_overlap (line 1609) | def test_error_on_facet_overlap(self, long_df, variables):
    method test_error_on_wrap_overlap (line 1618) | def test_error_on_wrap_overlap(self, long_df, variables):
    method test_axis_sharing (line 1630) | def test_axis_sharing(self, long_df):
    method test_axis_sharing_with_facets (line 1656) | def test_axis_sharing_with_facets(self, long_df):
    method test_x_wrapping (line 1675) | def test_x_wrapping(self, long_df):
    method test_y_wrapping (line 1688) | def test_y_wrapping(self, long_df):
    method test_non_cross_wrapping (line 1706) | def test_non_cross_wrapping(self, long_df):
    method test_cross_mismatched_lengths (line 1721) | def test_cross_mismatched_lengths(self, long_df):
    method test_orient_inference (line 1727) | def test_orient_inference(self, long_df):
    method test_computed_coordinate_orient_inference (line 1745) | def test_computed_coordinate_orient_inference(self, long_df):
    method test_two_variables_single_order_error (line 1756) | def test_two_variables_single_order_error(self, long_df):
    method test_limits (line 1763) | def test_limits(self, long_df):
    method test_labels (line 1770) | def test_labels(self, long_df):
  class TestLabelVisibility (line 1783) | class TestLabelVisibility:
    method has_xaxis_labels (line 1785) | def has_xaxis_labels(self, ax):
    method test_single_subplot (line 1796) | def test_single_subplot(self, long_df):
    method test_1d_column (line 1810) | def test_1d_column(self, long_df, facet_kws, pair_kws):
    method test_1d_row (line 1833) | def test_1d_row(self, long_df, facet_kws, pair_kws):
    method test_1d_column_wrapped (line 1853) | def test_1d_column_wrapped(self):
    method test_1d_row_wrapped (line 1878) | def test_1d_row_wrapped(self):
    method test_1d_column_wrapped_non_cross (line 1903) | def test_1d_column_wrapped_non_cross(self, long_df):
    method test_2d (line 1917) | def test_2d(self):
    method test_2d_unshared (line 1942) | def test_2d_unshared(self):
  class TestLegend (line 1973) | class TestLegend:
    method xy (line 1976) | def xy(self):
    method test_single_layer_single_variable (line 1979) | def test_single_layer_single_variable(self, xy):
    method test_single_layer_common_variable (line 1997) | def test_single_layer_common_variable(self, xy):
    method test_single_layer_common_unnamed_variable (line 2016) | def test_single_layer_common_unnamed_variable(self, xy):
    method test_single_layer_multi_variable (line 2036) | def test_single_layer_multi_variable(self, xy):
    method test_multi_layer_single_variable (line 2059) | def test_multi_layer_single_variable(self, xy):
    method test_multi_layer_multi_variable (line 2080) | def test_multi_layer_multi_variable(self, xy):
    method test_multi_layer_different_artists (line 2102) | def test_multi_layer_different_artists(self, xy):
    method test_three_layers (line 2126) | def test_three_layers(self, xy):
    method test_identity_scale_ignored (line 2140) | def test_identity_scale_ignored(self, xy):
    method test_suppression_in_add_method (line 2146) | def test_suppression_in_add_method(self, xy):
    method test_anonymous_title (line 2152) | def test_anonymous_title(self, xy):
    method test_legendless_mark (line 2158) | def test_legendless_mark(self, xy):
    method test_legend_has_no_offset (line 2167) | def test_legend_has_no_offset(self, xy):
    method test_layer_legend (line 2176) | def test_layer_legend(self, xy):
    method test_layer_legend_with_scale_legend (line 2184) | def test_layer_legend_with_scale_legend(self, xy):
    method test_layer_legend_title (line 2195) | def test_layer_legend_title(self, xy):
  class TestDefaultObject (line 2201) | class TestDefaultObject:
    method test_default_repr (line 2203) | def test_default_repr(self):
  class TestThemeConfig (line 2208) | class TestThemeConfig:
    method reset_config (line 2211) | def reset_config(self):
    method test_default (line 2215) | def test_default(self):
    method test_setitem (line 2222) | def test_setitem(self):
    method test_update (line 2230) | def test_update(self):
    method test_reset (line 2238) | def test_reset(self):
    method test_copy (line 2247) | def test_copy(self):
    method test_html_repr (line 2255) | def test_html_repr(self):
  class TestDisplayConfig (line 2265) | class TestDisplayConfig:
    method reset_config (line 2268) | def reset_config(self):
    method test_png_format (line 2272) | def test_png_format(self):
    method test_svg_format (line 2288) | def test_svg_format(self):
    method test_png_scaling (line 2303) | def test_png_scaling(self):
    method test_svg_scaling (line 2318) | def test_svg_scaling(self):
    method test_png_hidpi (line 2337) | def test_png_hidpi(self):

FILE: tests/_core/test_properties.py
  class DataFixtures (line 28) | class DataFixtures:
    method num_vector (line 31) | def num_vector(self, long_df):
    method num_order (line 35) | def num_order(self, num_vector):
    method cat_vector (line 39) | def cat_vector(self, long_df):
    method cat_order (line 43) | def cat_order(self, cat_vector):
    method dt_num_vector (line 47) | def dt_num_vector(self, long_df):
    method dt_cat_vector (line 51) | def dt_cat_vector(self, long_df):
    method bool_vector (line 55) | def bool_vector(self, long_df):
    method vectors (line 59) | def vectors(self, num_vector, cat_vector, bool_vector):
  class TestCoordinate (line 63) | class TestCoordinate(DataFixtures):
    method test_bad_scale_arg_str (line 65) | def test_bad_scale_arg_str(self, num_vector):
    method test_bad_scale_arg_type (line 71) | def test_bad_scale_arg_type(self, cat_vector):
  class TestColor (line 78) | class TestColor(DataFixtures):
    method assert_same_rgb (line 80) | def assert_same_rgb(self, a, b):
    method test_nominal_default_palette (line 83) | def test_nominal_default_palette(self, cat_vector, cat_order):
    method test_nominal_default_palette_large (line 92) | def test_nominal_default_palette_large(self):
    method test_nominal_named_palette (line 101) | def test_nominal_named_palette(self, cat_vector, cat_order):
    method test_nominal_list_palette (line 111) | def test_nominal_list_palette(self, cat_vector, cat_order):
    method test_nominal_dict_palette (line 120) | def test_nominal_dict_palette(self, cat_vector, cat_order):
    method test_nominal_dict_with_missing_keys (line 131) | def test_nominal_dict_with_missing_keys(self, cat_vector, cat_order):
    method test_nominal_list_too_short (line 137) | def test_nominal_list_too_short(self, cat_vector, cat_order):
    method test_nominal_list_too_long (line 145) | def test_nominal_list_too_long(self, cat_vector, cat_order):
    method test_continuous_default_palette (line 153) | def test_continuous_default_palette(self, num_vector):
    method test_continuous_named_palette (line 159) | def test_continuous_named_palette(self, num_vector):
    method test_continuous_tuple_palette (line 166) | def test_continuous_tuple_palette(self, num_vector):
    method test_continuous_callable_palette (line 173) | def test_continuous_callable_palette(self, num_vector):
    method test_continuous_missing (line 179) | def test_continuous_missing(self):
    method test_bad_scale_values_continuous (line 185) | def test_bad_scale_values_continuous(self, num_vector):
    method test_bad_scale_values_nominal (line 190) | def test_bad_scale_values_nominal(self, cat_vector):
    method test_bad_inference_arg (line 195) | def test_bad_inference_arg(self, cat_vector):
    method test_default (line 204) | def test_default(self, data_type, scale_class, vectors):
    method test_default_numeric_data_category_dtype (line 209) | def test_default_numeric_data_category_dtype(self, num_vector):
    method test_default_binary_data (line 214) | def test_default_binary_data(self):
    method test_inference (line 235) | def test_inference(self, values, data_type, scale_class, vectors):
    method test_standardization (line 241) | def test_standardization(self):
  class ObjectPropertyBase (line 257) | class ObjectPropertyBase(DataFixtures):
    method assert_equal (line 259) | def assert_equal(self, a, b):
    method unpack (line 263) | def unpack(self, x):
    method test_default (line 267) | def test_default(self, data_type, vectors):
    method test_inference_list (line 273) | def test_inference_list(self, data_type, vectors):
    method test_inference_dict (line 280) | def test_inference_dict(self, data_type, vectors):
    method test_dict_missing (line 288) | def test_dict_missing(self, cat_vector):
    method test_mapping_default (line 299) | def test_mapping_default(self, data_type, vectors):
    method test_mapping_from_list (line 309) | def test_mapping_from_list(self, data_type, vectors):
    method test_mapping_from_dict (line 319) | def test_mapping_from_dict(self, data_type, vectors):
    method test_mapping_with_null_value (line 333) | def test_mapping_with_null_value(self, cat_vector):
    method test_unique_default_large_n (line 342) | def test_unique_default_large_n(self):
    method test_bad_scale_values (line 349) | def test_bad_scale_values(self, cat_vector):
  class TestMarker (line 356) | class TestMarker(ObjectPropertyBase):
    method assert_equal (line 362) | def assert_equal(self, a, b):
    method unpack (line 373) | def unpack(self, x):
  class TestLineStyle (line 382) | class TestLineStyle(ObjectPropertyBase):
    method test_bad_type (line 388) | def test_bad_type(self):
    method test_bad_style (line 394) | def test_bad_style(self):
    method test_bad_dashes (line 400) | def test_bad_dashes(self):
  class TestFill (line 407) | class TestFill(DataFixtures):
    method vectors (line 410) | def vectors(self):
    method cat_vector (line 419) | def cat_vector(self, vectors):
    method num_vector (line 423) | def num_vector(self, vectors):
    method test_default (line 427) | def test_default(self, data_type, vectors):
    method test_inference_list (line 434) | def test_inference_list(self, data_type, vectors):
    method test_inference_dict (line 442) | def test_inference_dict(self, data_type, vectors):
    method test_mapping_categorical_data (line 450) | def test_mapping_categorical_data(self, cat_vector):
    method test_mapping_numeric_data (line 455) | def test_mapping_numeric_data(self, num_vector):
    method test_mapping_list (line 460) | def test_mapping_list(self, cat_vector):
    method test_mapping_truthy_list (line 465) | def test_mapping_truthy_list(self, cat_vector):
    method test_mapping_dict (line 470) | def test_mapping_dict(self, cat_vector):
    method test_cycle_warning (line 476) | def test_cycle_warning(self):
    method test_values_error (line 482) | def test_values_error(self):
  class IntervalBase (line 489) | class IntervalBase(DataFixtures):
    method norm (line 491) | def norm(self, x):
    method test_default (line 499) | def test_default(self, data_type, scale_class, vectors):
    method test_inference (line 516) | def test_inference(self, arg, data_type, scale_class, vectors):
    method test_mapped_interval_numeric (line 523) | def test_mapped_interval_numeric(self, num_vector):
    method test_mapped_interval_categorical (line 528) | def test_mapped_interval_categorical(self, cat_vector):
    method test_bad_scale_values_numeric_data (line 534) | def test_bad_scale_values_numeric_data(self, num_vector):
    method test_bad_scale_values_categorical_data (line 547) | def test_bad_scale_values_categorical_data(self, cat_vector):
  class TestAlpha (line 555) | class TestAlpha(IntervalBase):
  class TestLineWidth (line 559) | class TestLineWidth(IntervalBase):
    method test_rcparam_default (line 562) | def test_rcparam_default(self):
  class TestEdgeWidth (line 568) | class TestEdgeWidth(IntervalBase):
    method test_rcparam_default (line 571) | def test_rcparam_default(self):
  class TestPointSize (line 577) | class TestPointSize(IntervalBase):
    method test_areal_scaling_numeric (line 580) | def test_areal_scaling_numeric(self, num_vector):
    method test_areal_scaling_categorical (line 589) | def test_areal_scaling_categorical(self, cat_vector):

FILE: tests/_core/test_rules.py
  function test_vartype_object (line 14) | def test_vartype_object():
  function test_variable_type (line 25) | def test_variable_type():
  function test_categorical_order (line 77) | def test_categorical_order():

FILE: tests/_core/test_scales.py
  class TestContinuous (line 31) | class TestContinuous:
    method x (line 34) | def x(self):
    method setup_ticks (line 37) | def setup_ticks(self, x, *args, **kwargs):
    method setup_labels (line 44) | def setup_labels(self, x, *args, **kwargs):
    method test_coordinate_defaults (line 52) | def test_coordinate_defaults(self, x):
    method test_coordinate_transform (line 57) | def test_coordinate_transform(self, x):
    method test_coordinate_transform_with_parameter (line 62) | def test_coordinate_transform_with_parameter(self, x):
    method test_coordinate_transform_error (line 67) | def test_coordinate_transform_error(self, x):
    method test_interval_defaults (line 73) | def test_interval_defaults(self, x):
    method test_interval_with_range (line 78) | def test_interval_with_range(self, x):
    method test_interval_with_norm (line 83) | def test_interval_with_norm(self, x):
    method test_interval_with_range_norm_and_transform (line 88) | def test_interval_with_range_norm_and_transform(self, x):
    method test_interval_with_bools (line 95) | def test_interval_with_bools(self):
    method test_color_defaults (line 101) | def test_color_defaults(self, x):
    method test_color_named_values (line 107) | def test_color_named_values(self, x):
    method test_color_tuple_values (line 113) | def test_color_tuple_values(self, x):
    method test_color_callable_values (line 119) | def test_color_callable_values(self, x):
    method test_color_with_norm (line 125) | def test_color_with_norm(self, x):
    method test_color_with_transform (line 131) | def test_color_with_transform(self, x):
    method test_tick_locator (line 138) | def test_tick_locator(self, x):
    method test_tick_locator_input_check (line 145) | def test_tick_locator_input_check(self, x):
    method test_tick_upto (line 151) | def test_tick_upto(self, x):
    method test_tick_every (line 157) | def test_tick_every(self, x):
    method test_tick_every_between (line 163) | def test_tick_every_between(self, x):
    method test_tick_at (line 171) | def test_tick_at(self, x):
    method test_tick_count (line 177) | def test_tick_count(self, x):
    method test_tick_count_between (line 183) | def test_tick_count_between(self, x):
    method test_tick_minor (line 190) | def test_tick_minor(self, x):
    method test_log_tick_default (line 201) | def test_log_tick_default(self, x):
    method test_log_tick_upto (line 209) | def test_log_tick_upto(self, x):
    method test_log_tick_count (line 216) | def test_log_tick_count(self, x):
    method test_log_tick_format_disabled (line 226) | def test_log_tick_format_disabled(self, x):
    method test_log_tick_every (line 235) | def test_log_tick_every(self, x):
    method test_symlog_tick_default (line 240) | def test_symlog_tick_default(self, x):
    method test_label_formatter (line 251) | def test_label_formatter(self, x):
    method test_label_like_pattern (line 259) | def test_label_like_pattern(self, x):
    method test_label_like_string (line 266) | def test_label_like_string(self, x):
    method test_label_like_function (line 273) | def test_label_like_function(self, x):
    method test_label_base (line 280) | def test_label_base(self, x):
    method test_label_unit (line 287) | def test_label_unit(self, x):
    method test_label_unit_with_sep (line 294) | def test_label_unit_with_sep(self, x):
    method test_label_empty_unit (line 301) | def test_label_empty_unit(self, x):
    method test_label_base_from_transform (line 308) | def test_label_base_from_transform(self, x):
    method test_label_type_checks (line 316) | def test_label_type_checks(self):
  class TestNominal (line 326) | class TestNominal:
    method x (line 329) | def x(self):
    method y (line 333) | def y(self):
    method test_coordinate_defaults (line 336) | def test_coordinate_defaults(self, x):
    method test_coordinate_with_order (line 341) | def test_coordinate_with_order(self, x):
    method test_coordinate_with_subset_order (line 346) | def test_coordinate_with_subset_order(self, x):
    method test_coordinate_axis (line 351) | def test_coordinate_axis(self, x):
    method test_coordinate_axis_with_order (line 359) | def test_coordinate_axis_with_order(self, x):
    method test_coordinate_axis_with_subset_order (line 368) | def test_coordinate_axis_with_subset_order(self, x):
    method test_coordinate_axis_with_category_dtype (line 377) | def test_coordinate_axis_with_category_dtype(self, x):
    method test_coordinate_numeric_data (line 387) | def test_coordinate_numeric_data(self, y):
    method test_coordinate_numeric_data_with_order (line 395) | def test_coordinate_numeric_data_with_order(self, y):
    method test_color_defaults (line 404) | def test_color_defaults(self, x):
    method test_color_named_palette (line 410) | def test_color_named_palette(self, x):
    method test_color_list_palette (line 417) | def test_color_list_palette(self, x):
    method test_color_dict_palette (line 423) | def test_color_dict_palette(self, x):
    method test_color_numeric_data (line 430) | def test_color_numeric_data(self, y):
    method test_color_numeric_with_order_subset (line 436) | def test_color_numeric_with_order_subset(self, y):
    method test_color_numeric_int_float_mix (line 444) | def test_color_numeric_int_float_mix(self):
    method test_color_alpha_in_palette (line 452) | def test_color_alpha_in_palette(self, x):
    method test_color_unknown_palette (line 458) | def test_color_unknown_palette(self, x):
    method test_object_defaults (line 465) | def test_object_defaults(self, x):
    method test_object_list (line 474) | def test_object_list(self, x):
    method test_object_dict (line 480) | def test_object_dict(self, x):
    method test_object_order (line 486) | def test_object_order(self, x):
    method test_object_order_subset (line 492) | def test_object_order_subset(self, x):
    method test_objects_that_are_weird (line 498) | def test_objects_that_are_weird(self, x):
    method test_alpha_default (line 504) | def test_alpha_default(self, x):
    method test_fill (line 509) | def test_fill(self):
    method test_fill_dict (line 515) | def test_fill_dict(self):
    method test_fill_nunique_warning (line 522) | def test_fill_nunique_warning(self):
    method test_interval_defaults (line 529) | def test_interval_defaults(self, x):
    method test_interval_tuple (line 537) | def test_interval_tuple(self, x):
    method test_interval_tuple_numeric (line 542) | def test_interval_tuple_numeric(self, y):
    method test_interval_list (line 547) | def test_interval_list(self, x):
    method test_interval_dict (line 553) | def test_interval_dict(self, x):
    method test_interval_with_transform (line 559) | def test_interval_with_transform(self, x):
    method test_empty_data (line 568) | def test_empty_data(self):
    method test_finalize (line 574) | def test_finalize(self, x):
  class TestTemporal (line 587) | class TestTemporal:
    method t (line 590) | def t(self):
    method x (line 595) | def x(self, t):
    method test_coordinate_defaults (line 598) | def test_coordinate_defaults(self, t, x):
    method test_interval_defaults (line 603) | def test_interval_defaults(self, t, x):
    method test_interval_with_range (line 609) | def test_interval_with_range(self, t, x):
    method test_interval_with_norm (line 617) | def test_interval_with_norm(self, t, x):
    method test_color_defaults (line 625) | def test_color_defaults(self, t, x):
    method test_color_named_values (line 632) | def test_color_named_values(self, t, x):
    method test_coordinate_axis (line 640) | def test_coordinate_axis(self, t, x):
    method test_tick_locator (line 650) | def test_tick_locator(self, t):
    method test_tick_upto (line 658) | def test_tick_upto(self, t, x):
    method test_label_formatter (line 666) | def test_label_formatter(self, t):
    method test_label_concise (line 675) | def test_label_concise(self, t, x):
  class TestBoolean (line 683) | class TestBoolean:
    method x (line 686) | def x(self):
    method test_coordinate (line 689) | def test_coordinate(self, x):
    method test_coordinate_axis (line 694) | def test_coordinate_axis(self, x):
    method test_coordinate_missing (line 710) | def test_coordinate_missing(self, x, dtype, value):
    method test_color_defaults (line 717) | def test_color_defaults(self, x):
    method test_color_list_palette (line 724) | def test_color_list_palette(self, x):
    method test_color_tuple_palette (line 731) | def test_color_tuple_palette(self, x):
    method test_color_dict_palette (line 738) | def test_color_dict_palette(self, x):
    method test_object_defaults (line 746) | def test_object_defaults(self, x):
    method test_object_list (line 758) | def test_object_list(self, x):
    method test_object_dict (line 765) | def test_object_dict(self, x):
    method test_fill (line 772) | def test_fill(self, x):
    method test_interval_defaults (line 777) | def test_interval_defaults(self, x):
    method test_interval_tuple (line 788) | def test_interval_tuple(self, x):
    method test_finalize (line 795) | def test_finalize(self, x):

FILE: tests/_core/test_subplots.py
  class TestSpecificationChecks (line 9) | class TestSpecificationChecks:
    method test_both_facets_and_wrap (line 11) | def test_both_facets_and_wrap(self):
    method test_cross_xy_pairing_and_wrap (line 18) | def test_cross_xy_pairing_and_wrap(self):
    method test_col_facets_and_x_pairing (line 25) | def test_col_facets_and_x_pairing(self):
    method test_wrapped_columns_and_y_pairing (line 33) | def test_wrapped_columns_and_y_pairing(self):
    method test_wrapped_x_pairing_and_facetd_rows (line 41) | def test_wrapped_x_pairing_and_facetd_rows(self):
  class TestSubplotSpec (line 50) | class TestSubplotSpec:
    method test_single_subplot (line 52) | def test_single_subplot(self):
    method test_single_facet (line 62) | def test_single_facet(self):
    method test_two_facets (line 75) | def test_two_facets(self):
    method test_col_facet_wrapped (line 94) | def test_col_facet_wrapped(self):
    method test_row_facet_wrapped (line 108) | def test_row_facet_wrapped(self):
    method test_col_facet_wrapped_single_row (line 122) | def test_col_facet_wrapped_single_row(self):
    method test_x_and_y_paired (line 136) | def test_x_and_y_paired(self):
    method test_x_paired (line 148) | def test_x_paired(self):
    method test_y_paired (line 159) | def test_y_paired(self):
    method test_x_paired_and_wrapped (line 170) | def test_x_paired_and_wrapped(self):
    method test_y_paired_and_wrapped (line 182) | def test_y_paired_and_wrapped(self):
    method test_y_paired_and_wrapped_single_row (line 194) | def test_y_paired_and_wrapped_single_row(self):
    method test_col_faceted_y_paired (line 206) | def test_col_faceted_y_paired(self):
    method test_row_faceted_x_paired (line 221) | def test_row_faceted_x_paired(self):
    method test_x_any_y_paired_non_cross (line 236) | def test_x_any_y_paired_non_cross(self):
    method test_x_any_y_paired_non_cross_wrapped (line 249) | def test_x_any_y_paired_non_cross_wrapped(self):
    method test_forced_unshared_facets (line 263) | def test_forced_unshared_facets(self):
  class TestSubplotElements (line 270) | class TestSubplotElements:
    method test_single_subplot (line 272) | def test_single_subplot(self):
    method test_single_facet_dim (line 288) | def test_single_facet_dim(self, dim):
    method test_single_facet_dim_wrapped (line 308) | def test_single_facet_dim_wrapped(self, dim):
    method test_both_facet_dims (line 338) | def test_both_facet_dims(self):
    method test_single_paired_var (line 374) | def test_single_paired_var(self, var):
    method test_single_paired_var_wrapped (line 403) | def test_single_paired_var_wrapped(self, var):
    method test_both_paired_variables (line 436) | def test_both_paired_variables(self):
    method test_both_paired_non_cross (line 467) | def test_both_paired_non_cross(self):
    method test_one_facet_one_paired (line 486) | def test_one_facet_one_paired(self, dim, var):

FILE: tests/_marks/test_area.py
  class TestArea (line 11) | class TestArea:
    method test_single_defaults (line 13) | def test_single_defaults(self):
    method test_set_properties (line 37) | def test_set_properties(self):
    method test_mapped_properties (line 66) | def test_mapped_properties(self):
    method test_unfilled (line 91) | def test_unfilled(self):
  class TestBand (line 101) | class TestBand:
    method test_range (line 103) | def test_range(self):
    method test_auto_range (line 116) | def test_auto_range(self):

FILE: tests/_marks/test_bar.py
  class TestBar (line 13) | class TestBar:
    method plot_bars (line 15) | def plot_bars(self, variables, mark_kws, layer_kws):
    method check_bar (line 21) | def check_bar(self, bar, x, y, width, height):
    method test_categorical_positions_vertical (line 28) | def test_categorical_positions_vertical(self):
    method test_categorical_positions_horizontal (line 37) | def test_categorical_positions_horizontal(self):
    method test_numeric_positions_vertical (line 46) | def test_numeric_positions_vertical(self):
    method test_numeric_positions_horizontal (line 55) | def test_numeric_positions_horizontal(self):
    method test_set_properties (line 64) | def test_set_properties(self):
    method test_mapped_properties (line 88) | def test_mapped_properties(self):
    method test_zero_height_skipped (line 101) | def test_zero_height_skipped(self):
    method test_artist_kws_clip (line 107) | def test_artist_kws_clip(self):
  class TestBars (line 114) | class TestBars:
    method x (line 117) | def x(self):
    method y (line 121) | def y(self):
    method color (line 125) | def color(self):
    method test_positions (line 128) | def test_positions(self, x, y):
    method test_positions_horizontal (line 141) | def test_positions_horizontal(self, x, y):
    method test_width (line 154) | def test_width(self, x, y):
    method test_mapped_color_direct_alpha (line 164) | def test_mapped_color_direct_alpha(self, x, y, color):
    method test_mapped_edgewidth (line 174) | def test_mapped_edgewidth(self, x, y):
    method test_auto_edgewidth (line 181) | def test_auto_edgewidth(self):
    method test_unfilled (line 194) | def test_unfilled(self, x, y):
    method test_log_scale (line 204) | def test_log_scale(self):

FILE: tests/_marks/test_base.py
  class TestMappable (line 13) | class TestMappable:
    method mark (line 15) | def mark(self, **features):
    method test_repr (line 29) | def test_repr(self):
    method test_input_checks (line 37) | def test_input_checks(self):
    method test_value (line 44) | def test_value(self):
    method test_default (line 53) | def test_default(self):
    method test_rcparam (line 62) | def test_rcparam(self):
    method test_depends (line 73) | def test_depends(self):
    method test_mapped (line 86) | def test_mapped(self):
    method test_color (line 102) | def test_color(self):
    method test_color_mapped_alpha (line 113) | def test_color_mapped_alpha(self):
    method test_color_scaled_as_strings (line 131) | def test_color_scaled_as_strings(self):
    method test_fillcolor (line 141) | def test_fillcolor(self):

FILE: tests/_marks/test_dot.py
  function default_palette (line 12) | def default_palette():
  class DotBase (line 17) | class DotBase:
    method check_offsets (line 19) | def check_offsets(self, points, x, y):
    method check_colors (line 25) | def check_colors(self, part, points, colors, alpha=None):
  class TestDot (line 33) | class TestDot(DotBase):
    method test_simple (line 35) | def test_simple(self):
    method test_filled_unfilled_mix (line 47) | def test_filled_unfilled_mix(self):
    method test_missing_coordinate_data (line 66) | def test_missing_coordinate_data(self):
    method test_missing_semantic_data (line 77) | def test_missing_semantic_data(self, prop):
  class TestDots (line 89) | class TestDots(DotBase):
    method test_simple (line 91) | def test_simple(self):
    method test_set_color (line 103) | def test_set_color(self):
    method test_map_color (line 115) | def test_map_color(self):
    method test_fill (line 128) | def test_fill(self):
    method test_pointsize (line 141) | def test_pointsize(self):
    method test_stroke (line 152) | def test_stroke(self):
    method test_filled_unfilled_mix (line 163) | def test_filled_unfilled_mix(self):

FILE: tests/_marks/test_line.py
  class TestPath (line 13) | class TestPath:
    method test_xy_data (line 15) | def test_xy_data(self):
    method test_shared_colors_direct (line 28) | def test_shared_colors_direct(self):
    method test_separate_colors_direct (line 39) | def test_separate_colors_direct(self):
    method test_shared_colors_mapped (line 50) | def test_shared_colors_mapped(self):
    method test_separate_colors_mapped (line 63) | def test_separate_colors_mapped(self):
    method test_color_with_alpha (line 77) | def test_color_with_alpha(self):
    method test_color_and_alpha (line 87) | def test_color_and_alpha(self):
    method test_other_props_direct (line 97) | def test_other_props_direct(self):
    method test_other_props_mapped (line 109) | def test_other_props_mapped(self):
    method test_capstyle (line 121) | def test_capstyle(self):
  class TestLine (line 139) | class TestLine:
    method test_xy_data (line 143) | def test_xy_data(self):
  class TestPaths (line 157) | class TestPaths:
    method test_xy_data (line 159) | def test_xy_data(self):
    method test_set_properties (line 175) | def test_set_properties(self):
    method test_mapped_properties (line 186) | def test_mapped_properties(self):
    method test_color_with_alpha (line 197) | def test_color_with_alpha(self):
    method test_color_and_alpha (line 205) | def test_color_and_alpha(self):
    method test_capstyle (line 213) | def test_capstyle(self):
  class TestLines (line 232) | class TestLines:
    method test_xy_data (line 234) | def test_xy_data(self):
    method test_single_orient_value (line 250) | def test_single_orient_value(self):
  class TestRange (line 261) | class TestRange:
    method test_xy_data (line 263) | def test_xy_data(self):
    method test_auto_range (line 277) | def test_auto_range(self):
    method test_mapped_color (line 288) | def test_mapped_color(self):
    method test_direct_properties (line 305) | def test_direct_properties(self):
  class TestDash (line 320) | class TestDash:
    method test_xy_data (line 322) | def test_xy_data(self):
    method test_xy_data_grouped (line 335) | def test_xy_data_grouped(self):
    method test_set_properties (line 350) | def test_set_properties(self):
    method test_mapped_properties (line 364) | def test_mapped_properties(self):
    method test_width (line 381) | def test_width(self):
    method test_dodge (line 394) | def test_dodge(self):

FILE: tests/_marks/test_text.py
  class TestText (line 12) | class TestText:
    method get_texts (line 14) | def get_texts(self, ax):
    method test_simple (line 21) | def test_simple(self):
    method test_set_properties (line 36) | def test_set_properties(self):
    method test_mapped_properties (line 54) | def test_mapped_properties(self):
    method test_mapped_alignment (line 72) | def test_mapped_alignment(self):
    method test_identity_fontsize (line 83) | def test_identity_fontsize(self):
    method test_offset_centered (line 93) | def test_offset_centered(self):
    method test_offset_valign (line 103) | def test_offset_valign(self):
    method test_offset_halign (line 117) | def test_offset_halign(self):

FILE: tests/_stats/test_aggregation.py
  class AggregationFixtures (line 12) | class AggregationFixtures:
    method df (line 15) | def df(self, rng):
    method get_groupby (line 25) | def get_groupby(self, df, orient):
  class TestAgg (line 32) | class TestAgg(AggregationFixtures):
    method test_default (line 34) | def test_default(self, df):
    method test_default_multi (line 44) | def test_default_multi(self, df):
    method test_func (line 67) | def test_func(self, df, func):
  class TestEst (line 78) | class TestEst(AggregationFixtures):
    method test_mean_sd (line 83) | def test_mean_sd(self, df, func):
    method test_sd_single_obs (line 96) | def test_sd_single_obs(self):
    method test_median_pi (line 106) | def test_median_pi(self, df):
    method test_weighted_mean (line 118) | def test_weighted_mean(self, df, rng):
    method test_seed (line 129) | def test_seed(self, df):

FILE: tests/_stats/test_counting.py
  class TestCount (line 12) | class TestCount:
    method df (line 15) | def df(self, rng):
    method get_groupby (line 25) | def get_groupby(self, df, orient):
    method test_single_grouper (line 31) | def test_single_grouper(self, df):
    method test_multiple_groupers (line 40) | def test_multiple_groupers(self, df):
  class TestHist (line 50) | class TestHist:
    method single_args (line 53) | def single_args(self):
    method triple_args (line 63) | def triple_args(self):
    method test_string_bins (line 72) | def test_string_bins(self, long_df):
    method test_int_bins (line 79) | def test_int_bins(self, long_df):
    method test_array_bins (line 87) | def test_array_bins(self, long_df):
    method test_binwidth (line 94) | def test_binwidth(self, long_df):
    method test_binrange (line 103) | def test_binrange(self, long_df):
    method test_discrete_bins (line 110) | def test_discrete_bins(self, long_df):
    method test_discrete_bins_from_nominal_scale (line 118) | def test_discrete_bins_from_nominal_scale(self, rng):
    method test_count_stat (line 127) | def test_count_stat(self, long_df, single_args):
    method test_probability_stat (line 133) | def test_probability_stat(self, long_df, single_args):
    method test_proportion_stat (line 139) | def test_proportion_stat(self, long_df, single_args):
    method test_percent_stat (line 145) | def test_percent_stat(self, long_df, single_args):
    method test_density_stat (line 151) | def test_density_stat(self, long_df, single_args):
    method test_frequency_stat (line 157) | def test_frequency_stat(self, long_df, single_args):
    method test_invalid_stat (line 163) | def test_invalid_stat(self):
    method test_cumulative_count (line 168) | def test_cumulative_count(self, long_df, single_args):
    method test_cumulative_proportion (line 174) | def test_cumulative_proportion(self, long_df, single_args):
    method test_cumulative_density (line 180) | def test_cumulative_density(self, long_df, single_args):
    method test_common_norm_default (line 186) | def test_common_norm_default(self, long_df, triple_args):
    method test_common_norm_false (line 192) | def test_common_norm_false(self, long_df, triple_args):
    method test_common_norm_subset (line 199) | def test_common_norm_subset(self, long_df, triple_args):
    method test_common_norm_warning (line 206) | def test_common_norm_warning(self, long_df, triple_args):
    method test_common_bins_default (line 212) | def test_common_bins_default(self, long_df, triple_args):
    method test_common_bins_false (line 221) | def test_common_bins_false(self, long_df, triple_args):
    method test_common_bins_subset (line 230) | def test_common_bins_subset(self, long_df, triple_args):
    method test_common_bins_warning (line 239) | def test_common_bins_warning(self, long_df, triple_args):
    method test_histogram_single (line 245) | def test_histogram_single(self, long_df, single_args):
    method test_histogram_multiple (line 253) | def test_histogram_multiple(self, long_df, triple_args):

FILE: tests/_stats/test_density.py
  class TestKDE (line 12) | class TestKDE:
    method df (line 15) | def df(self, rng):
    method get_groupby (line 25) | def get_groupby(self, df, orient):
    method integrate (line 30) | def integrate(self, y, x):
    method test_columns (line 37) | def test_columns(self, df, ori):
    method test_gridsize (line 47) | def test_gridsize(self, df, gridsize):
    method test_cut (line 59) | def test_cut(self, df, cut):
    method test_common_grid (line 72) | def test_common_grid(self, df, common_grid):
    method test_common_norm (line 88) | def test_common_norm(self, df, common_norm):
    method test_common_norm_variables (line 108) | def test_common_norm_variables(self, df):
    method test_common_input_checks (line 133) | def test_common_input_checks(self, df, param):
    method test_bw_adjust (line 146) | def test_bw_adjust(self, df):
    method test_bw_method_scalar (line 158) | def test_bw_method_scalar(self, df):
    method test_cumulative (line 172) | def test_cumulative(self, df, common_norm):
    method test_cumulative_requires_scipy (line 184) | def test_cumulative_requires_scipy(self):
    method test_singular (line 192) | def test_singular(self, df, vals):
    method test_missing (line 205) | def test_missing(self, df, col):

FILE: tests/_stats/test_order.py
  class Fixtures (line 13) | class Fixtures:
    method df (line 16) | def df(self, rng):
    method get_groupby (line 19) | def get_groupby(self, df, orient):
  class TestPerc (line 26) | class TestPerc(Fixtures):
    method test_int_k (line 28) | def test_int_k(self, df):
    method test_list_k (line 37) | def test_list_k(self, df):
    method test_orientation (line 46) | def test_orientation(self, df):
    method test_method (line 54) | def test_method(self, df):
    method test_grouped (line 67) | def test_grouped(self, df, rng):
    method test_with_na (line 79) | def test_with_na(self, df):

FILE: tests/_stats/test_regression.py
  class TestPolyFit (line 13) | class TestPolyFit:
    method df (line 16) | def df(self, rng):
    method test_no_grouper (line 26) | def test_no_grouper(self, df):
    method test_one_grouper (line 39) | def test_one_grouper(self, df):
    method test_missing_data (line 55) | def test_missing_data(self, df):

FILE: tests/conftest.py
  function close_figs (line 8) | def close_figs():
  function random_seed (line 15) | def random_seed():
  function rng (line 21) | def rng():
  function wide_df (line 27) | def wide_df(rng):
  function wide_array (line 36) | def wide_array(wide_df):
  function flat_series (line 43) | def flat_series(rng):
  function flat_array (line 50) | def flat_array(flat_series):
  function flat_list (line 56) | def flat_list(flat_series):
  function flat_data (line 62) | def flat_data(rng, request):
  function wide_list_of_series (line 76) | def wide_list_of_series(rng):
  function wide_list_of_arrays (line 83) | def wide_list_of_arrays(wide_list_of_series):
  function wide_list_of_lists (line 89) | def wide_list_of_lists(wide_list_of_series):
  function wide_dict_of_series (line 95) | def wide_dict_of_series(wide_list_of_series):
  function wide_dict_of_arrays (line 101) | def wide_dict_of_arrays(wide_list_of_series):
  function wide_dict_of_lists (line 107) | def wide_dict_of_lists(wide_list_of_series):
  function long_df (line 113) | def long_df(rng):
  function long_dict (line 140) | def long_dict(long_df):
  function repeated_df (line 146) | def repeated_df(rng):
  function null_df (line 158) | def null_df(rng, long_df):
  function object_df (line 170) | def object_df(rng, long_df):
  function null_series (line 180) | def null_series(flat_series):
  class MockConvertibleDataFrame (line 185) | class MockConvertibleDataFrame:
    method __init__ (line 188) | def __init__(self, data):
    method to_pandas (line 191) | def to_pandas(self, *args, **kwargs):
  function mock_long_df (line 198) | def mock_long_df(long_df):

FILE: tests/test_algorithms.py
  function random (line 10) | def random():
  function test_bootstrap (line 14) | def test_bootstrap(random):
  function test_bootstrap_length (line 24) | def test_bootstrap_length(random):
  function test_bootstrap_range (line 35) | def test_bootstrap_range(random):
  function test_bootstrap_multiarg (line 44) | def test_bootstrap_multiarg(random):
  function test_bootstrap_axis (line 57) | def test_bootstrap_axis(random):
  function test_bootstrap_seed (line 69) | def test_bootstrap_seed(random):
  function test_bootstrap_ols (line 78) | def test_bootstrap_ols(random):
  function test_bootstrap_units (line 102) | def test_bootstrap_units(random):
  function test_bootstrap_arglength (line 116) | def test_bootstrap_arglength():
  function test_bootstrap_string_func (line 122) | def test_bootstrap_string_func():
  function test_bootstrap_reproducibility (line 138) | def test_bootstrap_reproducibility(random):
  function test_nanaware_func_auto (line 158) | def test_nanaware_func_auto(random):
  function test_nanaware_func_warning (line 166) | def test_nanaware_func_warning(random):

FILE: tests/test_axisgrid.py
  class TestFacetGrid (line 28) | class TestFacetGrid:
    method test_self_data (line 37) | def test_self_data(self):
    method test_self_figure (line 42) | def test_self_figure(self):
    method test_self_axes (line 48) | def test_self_axes(self):
    method test_axes_array_size (line 54) | def test_axes_array_size(self):
    method test_single_axes (line 73) | def test_single_axes(self):
    method test_col_wrap (line 90) | def test_col_wrap(self):
    method test_normal_axes (line 118) | def test_normal_axes(self):
    method test_wrapped_axes (line 150) | def test_wrapped_axes(self):
    method test_axes_dict (line 162) | def test_axes_dict(self):
    method test_figure_size (line 189) | def test_figure_size(self):
    method test_figure_size_with_legend (line 200) | def test_figure_size_with_legend(self):
    method test_legend_data (line 213) | def test_legend_data(self):
    method test_legend_data_missing_level (line 236) | def test_legend_data_missing_level(self):
    method test_get_boolean_legend_data (line 261) | def test_get_boolean_legend_data(self):
    method test_legend_tuples (line 285) | def test_legend_tuples(self):
    method test_legend_options (line 297) | def test_legend_options(self):
    method test_legendout_with_colwrap (line 309) | def test_legendout_with_colwrap(self):
    method test_legend_tight_layout (line 316) | def test_legend_tight_layout(self):
    method test_subplot_kws (line 328) | def test_subplot_kws(self):
    method test_gridspec_kws (line 335) | def test_gridspec_kws(self):
    method test_gridspec_kws_col_wrap (line 351) | def test_gridspec_kws_col_wrap(self):
    method test_data_generator (line 358) | def test_data_generator(self):
    method test_map (line 398) | def test_map(self):
    method test_map_dataframe (line 413) | def test_map_dataframe(self):
    method test_set (line 434) | def test_set(self):
    method test_set_titles (line 448) | def test_set_titles(self):
    method test_set_titles_margin_titles (line 476) | def test_set_titles_margin_titles(self):
    method test_set_ticklabels (line 500) | def test_set_ticklabels(self):
    method test_set_axis_labels (line 534) | def test_set_axis_labels(self):
    method test_axis_lims (line 557) | def test_axis_lims(self):
    method test_data_orders (line 563) | def test_data_orders(self):
    method test_palette (line 592) | def test_palette(self):
    method test_hue_kws (line 615) | def test_hue_kws(self):
    method test_dropna (line 624) | def test_dropna(self):
    method test_categorical_column_missing_categories (line 636) | def test_categorical_column_missing_categories(self):
    method test_categorical_warning (line 645) | def test_categorical_warning(self):
    method test_refline (line 651) | def test_refline(self):
    method test_apply (line 675) | def test_apply(self, long_df):
    method test_pipe (line 686) | def test_pipe(self, long_df):
    method test_tick_params (line 698) | def test_tick_params(self):
    method test_data_interchange (line 715) | def test_data_interchange(self, mock_long_df, long_df):
  class TestPairGrid (line 725) | class TestPairGrid:
    method test_self_data (line 734) | def test_self_data(self):
    method test_ignore_datelike_data (line 739) | def test_ignore_datelike_data(self):
    method test_self_figure (line 747) | def test_self_figure(self):
    method test_self_axes (line 753) | def test_self_axes(self):
    method test_default_axes (line 759) | def test_default_axes(self):
    method test_specific_square_axes (line 768) | def test_specific_square_axes(self, vars):
    method test_remove_hue_from_default (line 776) | def test_remove_hue_from_default(self):
    method test_specific_nonsquare_axes (line 796) | def test_specific_nonsquare_axes(self, x_vars, y_vars):
    method test_corner (line 804) | def test_corner(self):
    method test_size (line 823) | def test_size(self):
    method test_empty_grid (line 835) | def test_empty_grid(self):
    method test_map (line 840) | def test_map(self):
    method test_map_nonsquare (line 868) | def test_map_nonsquare(self):
    method test_map_lower (line 883) | def test_map_lower(self):
    method test_map_upper (line 901) | def test_map_upper(self):
    method test_map_mixed_funcsig (line 919) | def test_map_mixed_funcsig(self):
    method test_map_diag (line 934) | def test_map_diag(self):
    method test_map_diag_rectangular (line 956) | def test_map_diag_rectangular(self):
    method test_map_diag_color (line 1016) | def test_map_diag_color(self):
    method test_map_diag_palette (line 1034) | def test_map_diag_palette(self):
    method test_map_diag_and_offdiag (line 1045) | def test_map_diag_and_offdiag(self):
    method test_diag_sharey (line 1075) | def test_diag_sharey(self):
    method test_map_diag_matplotlib (line 1082) | def test_map_diag_matplotlib(self):
    method test_palette (line 1096) | def test_palette(self):
    method test_hue_kws (line 1119) | def test_hue_kws(self):
    method test_hue_order (line 1135) | def test_hue_order(self):
    method test_hue_order_missing_level (line 1178) | def test_hue_order_missing_level(self):
    method test_hue_in_map (line 1221) | def test_hue_in_map(self, long_df):
    method test_nondefault_index (line 1229) | def test_nondefault_index(self):
    method test_dropna (line 1260) | def test_dropna(self, func):
    method test_histplot_legend (line 1288) | def test_histplot_legend(self):
    method test_pairplot (line 1297) | def test_pairplot(self):
    method test_pairplot_reg (line 1331) | def test_pairplot_reg(self):
    method test_pairplot_reg_hue (line 1365) | def test_pairplot_reg_hue(self):
    method test_pairplot_diag_kde (line 1379) | def test_pairplot_diag_kde(self):
    method test_pairplot_kde (line 1407) | def test_pairplot_kde(self):
    method test_pairplot_hist (line 1417) | def test_pairplot_hist(self):
    method test_pairplot_markers (line 1428) | def test_pairplot_markers(self):
    method test_pairplot_column_multiindex (line 1440) | def test_pairplot_column_multiindex(self):
    method test_corner_despine (line 1447) | def test_corner_despine(self):
    method test_corner_set (line 1453) | def test_corner_set(self):
    method test_legend (line 1459) | def test_legend(self):
    method test_tick_params (line 1467) | def test_tick_params(self):
    method test_data_interchange (line 1484) | def test_data_interchange(self, mock_long_df, long_df):
  class TestJointGrid (line 1494) | class TestJointGrid:
    method test_margin_grid_from_lists (line 1504) | def test_margin_grid_from_lists(self):
    method test_margin_grid_from_arrays (line 1510) | def test_margin_grid_from_arrays(self):
    method test_margin_grid_from_series (line 1516) | def test_margin_grid_from_series(self):
    method test_margin_grid_from_dataframe (line 1522) | def test_margin_grid_from_dataframe(self):
    method test_margin_grid_from_dataframe_bad_variable (line 1528) | def test_margin_grid_from_dataframe_bad_variable(self):
    method test_margin_grid_axis_labels (line 1533) | def test_margin_grid_axis_labels(self):
    method test_dropna (line 1546) | def test_dropna(self):
    method test_axlims (line 1554) | def test_axlims(self):
    method test_marginal_ticks (line 1565) | def test_marginal_ticks(self):
    method test_bivariate_plot (line 1575) | def test_bivariate_plot(self):
    method test_univariate_plot (line 1584) | def test_univariate_plot(self):
    method test_univariate_plot_distplot (line 1593) | def test_univariate_plot_distplot(self):
    method test_univariate_plot_matplotlib (line 1604) | def test_univariate_plot_matplotlib(self):
    method test_plot (line 1612) | def test_plot(self):
    method test_space (line 1625) | def test_space(self):
    method test_hue (line 1639) | def test_hue(self, long_df, as_vector):
    method test_refline (line 1661) | def test_refline(self):
  class TestJointPlot (line 1705) | class TestJointPlot:
    method test_scatter (line 1712) | def test_scatter(self):
    method test_scatter_hue (line 1731) | def test_scatter_hue(self, long_df):
    method test_reg (line 1744) | def test_reg(self):
    method test_resid (line 1759) | def test_resid(self):
    method test_hist (line 1767) | def test_hist(self, long_df):
    method test_hex (line 1781) | def test_hex(self):
    method test_kde (line 1788) | def test_kde(self, long_df):
    method test_kde_hue (line 1801) | def test_kde_hue(self, long_df):
    method test_color (line 1814) | def test_color(self):
    method test_palette (line 1824) | def test_palette(self, long_df):
    method test_hex_customise (line 1839) | def test_hex_customise(self):
    method test_bad_kind (line 1848) | def test_bad_kind(self):
    method test_unsupported_hue_kind (line 1853) | def test_unsupported_hue_kind(self):
    method test_leaky_dict (line 1859) | def test_leaky_dict(self):
    method test_distplot_kwarg_warning (line 1869) | def test_distplot_kwarg_warning(self, long_df):
    method test_ax_warning (line 1875) | def test_ax_warning(self, long_df):

FILE: tests/test_base.py
  function long_variables (line 43) | def long_variables(request):
  class TestSemanticMapping (line 47) | class TestSemanticMapping:
    method test_call_lookup (line 49) | def test_call_lookup(self):
  class TestHueMapping (line 58) | class TestHueMapping:
    method test_plotter_default_init (line 60) | def test_plotter_default_init(self, long_df):
    method test_plotter_customization (line 75) | def test_plotter_customization(self, long_df):
    method test_hue_map_null (line 87) | def test_hue_map_null(self, flat_series, null_series):
    method test_hue_map_categorical (line 98) | def test_hue_map_categorical(self, wide_df, long_df):
    method test_hue_map_numeric (line 220) | def test_hue_map_numeric(self, long_df):
    method test_hue_map_without_hue_dataa (line 302) | def test_hue_map_without_hue_dataa(self, long_df):
    method test_saturation (line 308) | def test_saturation(self, long_df):
  class TestSizeMapping (line 320) | class TestSizeMapping:
    method test_plotter_default_init (line 322) | def test_plotter_default_init(self, long_df):
    method test_plotter_customization (line 337) | def test_plotter_customization(self, long_df):
    method test_size_map_null (line 349) | def test_size_map_null(self, flat_series, null_series):
    method test_map_size_numeric (line 358) | def test_map_size_numeric(self, long_df):
    method test_map_size_categorical (line 403) | def test_map_size_categorical(self, long_df):
    method test_array_palette_deprecation (line 454) | def test_array_palette_deprecation(self, long_df):
  class TestStyleMapping (line 463) | class TestStyleMapping:
    method test_plotter_default_init (line 465) | def test_plotter_default_init(self, long_df):
    method test_plotter_customization (line 479) | def test_plotter_customization(self, long_df):
    method test_style_map_null (line 491) | def test_style_map_null(self, flat_series, null_series):
    method test_map_style (line 499) | def test_map_style(self, long_df):
  class TestVectorPlotter (line 576) | class TestVectorPlotter:
    method test_flat_variables (line 578) | def test_flat_variables(self, flat_data):
    method test_long_df (line 605) | def test_long_df(self, long_df, long_variables):
    method test_long_df_with_index (line 615) | def test_long_df_with_index(self, long_df, long_variables):
    method test_long_df_with_multiindex (line 628) | def test_long_df_with_multiindex(self, long_df, long_variables):
    method test_long_dict (line 641) | def test_long_dict(self, long_dict, long_variables):
    method test_long_vectors (line 658) | def test_long_vectors(self, long_df, long_variables, vector_type):
    method test_long_undefined_variables (line 677) | def test_long_undefined_variables(self, long_df):
    method test_empty_data_input (line 699) | def test_empty_data_input(self, arg):
    method test_units (line 710) | def test_units(self, repeated_df):
    method test_long_numeric_name (line 720) | def test_long_numeric_name(self, long_df, name):
    method test_long_hierarchical_index (line 728) | def test_long_hierarchical_index(self, rng):
    method test_long_scalar_and_data (line 742) | def test_long_scalar_and_data(self, long_df):
    method test_wide_semantic_error (line 749) | def test_wide_semantic_error(self, wide_df):
    method test_long_unknown_error (line 755) | def test_long_unknown_error(self, long_df):
    method test_long_unmatched_size_error (line 761) | def test_long_unmatched_size_error(self, long_df, flat_array):
    method test_wide_categorical_columns (line 767) | def test_wide_categorical_columns(self, wide_df):
    method test_iter_data_quantitites (line 773) | def test_iter_data_quantitites(self, long_df):
    method test_iter_data_keys (line 865) | def test_iter_data_keys(self, long_df):
    method test_iter_data_values (line 927) | def test_iter_data_values(self, long_df):
    method test_iter_data_reverse (line 956) | def test_iter_data_reverse(self, long_df):
    method test_iter_data_dropna (line 967) | def test_iter_data_dropna(self, null_df):
    method test_axis_labels (line 982) | def test_axis_labels(self, long_df):
    method test_attach_basics (line 1042) | def test_attach_basics(self, long_df, variables):
    method test_attach_disallowed (line 1049) | def test_attach_disallowed(self, long_df):
    method test_attach_log_scale (line 1072) | def test_attach_log_scale(self, long_df):
    method test_attach_converters (line 1128) | def test_attach_converters(self, long_df):
    method test_attach_facets (line 1142) | def test_attach_facets(self, long_df):
    method test_scale_transform_identity (line 1150) | def test_scale_transform_identity(self, long_df):
    method test_scale_transform_identity_facets (line 1161) | def test_scale_transform_identity_facets(self, long_df):
    method test_scale_transform_log (line 1172) | def test_scale_transform_log(self, long_df):
    method test_scale_transform_facets (line 1184) | def test_scale_transform_facets(self, long_df):
    method test_scale_transform_mixed_facets (line 1194) | def test_scale_transform_mixed_facets(self, long_df):
    method test_attach_shared_axes (line 1205) | def test_attach_shared_axes(self, long_df):
    method test_get_axes_single (line 1266) | def test_get_axes_single(self, long_df):
    method test_get_axes_facets (line 1273) | def test_get_axes_facets(self, long_df):
    method test_comp_data (line 1287) | def test_comp_data(self, long_df):
    method test_comp_data_log (line 1313) | def test_comp_data_log(self, long_df):
    method test_comp_data_category_order (line 1324) | def test_comp_data_category_order(self):
    method comp_data_missing_fixture (line 1343) | def comp_data_missing_fixture(self, request):
    method test_comp_data_missing (line 1367) | def test_comp_data_missing(self, comp_data_missing_fixture):
    method test_comp_data_duplicate_index (line 1376) | def test_comp_data_duplicate_index(self):
    method test_comp_data_nullable_dtype (line 1384) | def test_comp_data_nullable_dtype(self):
    method test_var_order (line 1393) | def test_var_order(self, long_df):
    method test_scale_native (line 1404) | def test_scale_native(self, long_df):
    method test_scale_numeric (line 1410) | def test_scale_numeric(self, long_df):
    method test_scale_datetime (line 1416) | def test_scale_datetime(self, long_df):
    method test_scale_categorical (line 1422) | def test_scale_categorical(self, long_df):
  class TestCoreFunc (line 1460) | class TestCoreFunc:
    method test_unique_dashes (line 1462) | def test_unique_dashes(self):
    method test_unique_markers (line 1474) | def test_unique_markers(self):
    method test_variable_type (line 1484) | def test_variable_type(self):
    method test_infer_orient (line 1528) | def test_infer_orient(self):
    method test_categorical_order (line 1573) | def test_categorical_order(self):

FILE: tests/test_categorical.py
  class TestCategoricalPlotterNew (line 54) | class TestCategoricalPlotterNew:
    method test_axis_labels (line 68) | def test_axis_labels(self, long_df, func, kwargs):
    method test_empty (line 79) | def test_empty(self, func):
    method test_redundant_hue_backcompat (line 93) | def test_redundant_hue_backcompat(self, long_df):
  class SharedAxesLevelTests (line 111) | class SharedAxesLevelTests:
    method orient_indices (line 113) | def orient_indices(self, orient):
    method common_kws (line 119) | def common_kws(self):
    method test_labels_long (line 123) | def test_labels_long(self, long_df, orient):
    method test_labels_wide (line 148) | def test_labels_wide(self, wide_df):
    method test_labels_hue_order (line 161) | def test_labels_hue_order(self, long_df):
    method test_color (line 170) | def test_color(self, long_df, common_kws):
    method test_two_calls (line 190) | def test_two_calls(self):
    method test_redundant_hue_legend (line 197) | def test_redundant_hue_legend(self, long_df):
    method test_log_scale (line 207) | def test_log_scale(self, long_df, orient):
  class SharedScatterTests (line 216) | class SharedScatterTests(SharedAxesLevelTests):
    method get_last_color (line 219) | def get_last_color(self, ax):
    method test_color (line 228) | def test_color(self, long_df, common_kws):
    method test_supplied_color_array (line 240) | def test_supplied_color_array(self, long_df):
    method test_unfilled_marker (line 260) | def test_unfilled_marker(self, long_df):
    method test_wide (line 277) | def test_wide(self, wide_df, orient, data_type):
    method test_flat (line 306) | def test_flat(self, flat_series, orient):
    method test_positions (line 342) | def test_positions(self, long_df, variables, orient):
    method test_positions_dodged (line 390) | def test_positions_dodged(self, long_df, variables):
    method test_positions_unfixed (line 429) | def test_positions_unfixed(self, long_df, cat_var):
    method test_order (line 464) | def test_order(self, x_type, order):
    method test_hue_categorical (line 497) | def test_hue_categorical(self, long_df, hue_var):
    method test_hue_dodged (line 522) | def test_hue_dodged(self, long_df, hue_var):
    method test_single (line 542) | def test_single(self, long_df, val_var, val_col, hue_col):
    method test_attributes (line 586) | def test_attributes(self, long_df):
    method test_three_points (line 601) | def test_three_points(self):
    method test_legend_categorical (line 608) | def test_legend_categorical(self, long_df):
    method test_legend_numeric (line 615) | def test_legend_numeric(self, long_df):
    method test_legend_attributes (line 621) | def test_legend_attributes(self, long_df):
    method test_legend_disabled (line 629) | def test_legend_disabled(self, long_df):
    method test_palette_from_color_deprecation (line 634) | def test_palette_from_color_deprecation(self, long_df):
    method test_palette_with_hue_deprecation (line 650) | def test_palette_with_hue_deprecation(self, long_df):
    method test_log_scale (line 659) | def test_log_scale(self):
    method test_vs_catplot (line 700) | def test_vs_catplot(self, long_df, wide_df, kwargs):
    method test_empty_palette (line 723) | def test_empty_palette(self):
  class SharedAggTests (line 727) | class SharedAggTests(SharedAxesLevelTests):
    method test_labels_flat (line 729) | def test_labels_flat(self):
  class SharedPatchArtistTests (line 746) | class SharedPatchArtistTests:
    method test_legend_fill (line 749) | def test_legend_fill(self, long_df, fill):
    method test_legend_attributes (line 766) | def test_legend_attributes(self, long_df):
  class TestStripPlot (line 773) | class TestStripPlot(SharedScatterTests):
    method test_jitter_unfixed (line 777) | def test_jitter_unfixed(self, long_df):
    method test_jitter (line 797) | def test_jitter(self, long_df, orient, jitter):
  class TestSwarmPlot (line 830) | class TestSwarmPlot(SharedScatterTests):
  class TestBoxPlot (line 835) | class TestBoxPlot(SharedAxesLevelTests, SharedPatchArtistTests):
    method common_kws (line 840) | def common_kws(self):
    method get_last_color (line 843) | def get_last_color(self, ax):
    method get_box_verts (line 850) | def get_box_verts(self, box):
    method check_box (line 857) | def check_box(self, bxp, data, orient, pos, width=0.8):
    method check_whiskers (line 873) | def check_whiskers(self, bxp, data, orient, pos, capsize=0.4, whis=1.5):
    method test_single_var (line 906) | def test_single_var(self, long_df, orient, col):
    method test_vector_data (line 915) | def test_vector_data(self, long_df, orient, col):
    method test_wide_data (line 924) | def test_wide_data(self, wide_df, orient):
    method test_grouped (line 934) | def test_grouped(self, long_df, orient):
    method test_hue_grouped (line 946) | def test_hue_grouped(self, long_df, orient):
    method test_hue_not_dodged (line 960) | def test_hue_not_dodged(self, long_df):
    method test_dodge_native_scale (line 972) | def test_dodge_native_scale(self, long_df):
    method test_dodge_native_scale_log (line 989) | def test_dodge_native_scale_log(self, long_df):
    method test_dodge_without_hue (line 1002) | def test_dodge_without_hue(self, long_df):
    method test_log_data_scale (line 1013) | def test_log_data_scale(self, long_df, orient):
    method test_color (line 1024) | def test_color(self, long_df):
    method test_wide_data_multicolored (line 1031) | def test_wide_data_multicolored(self, wide_df):
    method test_wide_data_single_color (line 1036) | def test_wide_data_single_color(self, wide_df):
    method test_hue_colors (line 1043) | def test_hue_colors(self, long_df):
    method test_linecolor (line 1050) | def test_linecolor(self, long_df):
    method test_linecolor_gray_warning (line 1062) | def test_linecolor_gray_warning(self, long_df):
    method test_saturation (line 1067) | def test_saturation(self, long_df):
    method test_linewidth (line 1074) | def test_linewidth(self, long_df):
    method test_fill (line 1082) | def test_fill(self, long_df):
    method test_notch (line 1092) | def test_notch(self, long_df, notch_param):
    method test_whis (line 1098) | def test_whis(self, long_df):
    method test_gap (line 1105) | def test_gap(self, long_df):
    method test_prop_dicts (line 1117) | def test_prop_dicts(self, long_df):
    method test_showfliers (line 1135) | def test_showfliers(self, long_df):
    method test_vs_catplot (line 1162) | def test_vs_catplot(self, long_df, wide_df, null_df, flat_series, kwar...
  class TestBoxenPlot (line 1183) | class TestBoxenPlot(SharedAxesLevelTests, SharedPatchArtistTests):
    method common_kws (line 1188) | def common_kws(self):
    method get_last_color (line 1191) | def get_last_color(self, ax):
    method get_box_width (line 1196) | def get_box_width(self, path, orient="x"):
    method check_boxen (line 1202) | def check_boxen(self, patches, data, orient, pos, width=0.8):
    method test_single_var (line 1215) | def test_single_var(self, long_df, orient, col):
    method test_vector_data (line 1223) | def test_vector_data(self, long_df, orient, col):
    method test_wide_data (line 1231) | def test_wide_data(self, wide_df, orient):
    method test_grouped (line 1241) | def test_grouped(self, long_df, orient):
    method test_hue_grouped (line 1252) | def test_hue_grouped(self, long_df, orient):
    method test_dodge_native_scale (line 1265) | def test_dodge_native_scale(self, long_df):
    method test_color (line 1281) | def test_color(self, long_df):
    method test_hue_colors (line 1290) | def test_hue_colors(self, long_df):
    method test_linecolor (line 1299) | def test_linecolor(self, long_df):
    method test_linewidth (line 1306) | def test_linewidth(self, long_df):
    method test_saturation (line 1313) | def test_saturation(self, long_df):
    method test_gap (line 1320) | def test_gap(self, long_df):
    method test_fill (line 1332) | def test_fill(self, long_df):
    method test_k_depth_int (line 1338) | def test_k_depth_int(self, rng):
    method test_k_depth_full (line 1344) | def test_k_depth_full(self, rng):
    method test_trust_alpha (line 1355) | def test_trust_alpha(self, rng):
    method test_outlier_prop (line 1363) | def test_outlier_prop(self, rng):
    method test_exponential_width_method (line 1371) | def test_exponential_width_method(self, rng):
    method test_linear_width_method (line 1379) | def test_linear_width_method(self, rng):
    method test_area_width_method (line 1387) | def test_area_width_method(self, rng):
    method test_box_kws (line 1395) | def test_box_kws(self, long_df):
    method test_line_kws (line 1401) | def test_line_kws(self, long_df):
    method test_flier_kws (line 1407) | def test_flier_kws(self, long_df):
    method test_k_depth_checks (line 1414) | def test_k_depth_checks(self, long_df):
    method test_width_method_check (line 1422) | def test_width_method_check(self, long_df):
    method test_scale_deprecation (line 1427) | def test_scale_deprecation(self, long_df):
    method test_vs_catplot (line 1459) | def test_vs_catplot(self, long_df, wide_df, null_df, flat_series, kwar...
  class TestViolinPlot (line 1480) | class TestViolinPlot(SharedAxesLevelTests, SharedPatchArtistTests):
    method common_kws (line 1485) | def common_kws(self):
    method get_last_color (line 1488) | def get_last_color(self, ax):
    method violin_width (line 1493) | def violin_width(self, poly, orient="x"):
    method check_violin (line 1498) | def check_violin(self, poly, data, orient, pos, width=0.8):
    method test_single_var (line 1510) | def test_single_var(self, long_df, orient, col):
    method test_vector_data (line 1518) | def test_vector_data(self, long_df, orient, col):
    method test_wide_data (line 1526) | def test_wide_data(self, wide_df, orient):
    method test_grouped (line 1535) | def test_grouped(self, long_df, orient):
    method test_hue_grouped (line 1545) | def test_hue_grouped(self, long_df, orient):
    method test_hue_not_dodged (line 1558) | def test_hue_not_dodged(self, long_df):
    method test_dodge_native_scale (line 1568) | def test_dodge_native_scale(self, long_df):
    method test_dodge_native_scale_log (line 1585) | def test_dodge_native_scale_log(self, long_df):
    method test_color (line 1600) | def test_color(self, long_df):
    method test_hue_colors (line 1607) | def test_hue_colors(self, long_df):
    method test_linecolor (line 1615) | def test_linecolor(self, long_df, inner):
    method test_linewidth (line 1626) | def test_linewidth(self, long_df):
    method test_saturation (line 1633) | def test_saturation(self, long_df):
    method test_fill (line 1641) | def test_fill(self, long_df, inner):
    method test_inner_box (line 1654) | def test_inner_box(self, long_df, orient):
    method test_inner_quartiles (line 1675) | def test_inner_quartiles(self, long_df, orient):
    method test_inner_stick (line 1688) | def test_inner_stick(self, long_df, orient):
    method test_inner_points (line 1698) | def test_inner_points(self, long_df, orient):
    method test_split_single (line 1707) | def test_split_single(self, long_df):
    method test_split_multi (line 1717) | def test_split_multi(self, long_df):
    method test_density_norm_area (line 1731) | def test_density_norm_area(self, long_df):
    method test_density_norm_count (line 1740) | def test_density_norm_count(self, long_df):
    method test_density_norm_width (line 1749) | def test_density_norm_width(self, long_df):
    method test_common_norm (line 1755) | def test_common_norm(self, long_df):
    method test_scale_deprecation (line 1763) | def test_scale_deprecation(self, long_df):
    method test_scale_hue_deprecation (line 1768) | def test_scale_hue_deprecation(self, long_df):
    method test_bw_adjust (line 1773) | def test_bw_adjust(self, long_df):
    method test_bw_deprecation (line 1781) | def test_bw_deprecation(self, long_df):
    method test_gap (line 1786) | def test_gap(self, long_df):
    method test_inner_kws (line 1793) | def test_inner_kws(self, long_df):
    method test_box_inner_kws (line 1800) | def test_box_inner_kws(self, long_df):
    method test_vs_catplot (line 1836) | def test_vs_catplot(self, long_df, wide_df, null_df, flat_series, kwar...
  class TestBarPlot (line 1857) | class TestBarPlot(SharedAggTests):
    method common_kws (line 1862) | def common_kws(self):
    method get_last_color (line 1865) | def get_last_color(self, ax):
    method test_single_var (line 1873) | def test_single_var(self, orient):
    method test_wide_df (line 1882) | def test_wide_df(self, wide_df, orient):
    method test_vector_orient (line 1891) | def test_vector_orient(self, orient):
    method test_xy_vertical (line 1902) | def test_xy_vertical(self):
    method test_xy_horizontal (line 1913) | def test_xy_horizontal(self):
    method test_xy_with_na_grouper (line 1924) | def test_xy_with_na_grouper(self):
    method test_xy_with_na_value (line 1934) | def test_xy_with_na_value(self):
    method test_hue_redundant (line 1944) | def test_hue_redundant(self):
    method test_hue_matched (line 1956) | def test_hue_matched(self):
    method test_hue_matched_by_name (line 1969) | def test_hue_matched_by_name(self):
    method test_hue_dodged (line 1980) | def test_hue_dodged(self):
    method test_gap (line 1998) | def test_gap(self):
    method test_hue_undodged (line 2008) | def test_hue_undodged(self):
    method test_hue_order (line 2022) | def test_hue_order(self):
    method test_hue_norm (line 2032) | def test_hue_norm(self):
    method test_fill (line 2042) | def test_fill(self):
    method test_xy_native_scale (line 2053) | def test_xy_native_scale(self):
    method test_xy_native_scale_log_transform (line 2064) | def test_xy_native_scale_log_transform(self):
    method test_datetime_native_scale_axis (line 2079) | def test_datetime_native_scale_axis(self):
    method test_native_scale_dodged (line 2088) | def test_native_scale_dodged(self):
    method test_native_scale_log_transform_dodged (line 2100) | def test_native_scale_log_transform_dodged(self):
    method test_estimate_default (line 2114) | def test_estimate_default(self, long_df):
    method test_estimate_string (line 2124) | def test_estimate_string(self, long_df):
    method test_estimate_func (line 2134) | def test_estimate_func(self, long_df):
    method test_weighted_estimate (line 2144) | def test_weighted_estimate(self, long_df):
    method test_estimate_log_transform (line 2151) | def test_estimate_log_transform(self, long_df):
    method test_errorbars (line 2159) | def test_errorbars(self, long_df):
    method test_width (line 2172) | def test_width(self):
    method test_width_native_scale (line 2181) | def test_width_native_scale(self):
    method test_width_spaced_categories (line 2189) | def test_width_spaced_categories(self):
    method test_saturation_color (line 2196) | def test_saturation_color(self):
    method test_saturation_palette (line 2204) | def test_saturation_palette(self):
    method test_legend_numeric_auto (line 2212) | def test_legend_numeric_auto(self, long_df):
    method test_legend_numeric_full (line 2217) | def test_legend_numeric_full(self, long_df):
    method test_legend_disabled (line 2224) | def test_legend_disabled(self, long_df):
    method test_error_caps (line 2229) | def test_error_caps(self):
    method test_error_caps_native_scale (line 2241) | def test_error_caps_native_scale(self):
    method test_error_caps_native_scale_log_transform (line 2253) | def test_error_caps_native_scale_log_transform(self):
    method test_bar_kwargs (line 2267) | def test_bar_kwargs(self):
    method test_legend_attributes (line 2277) | def test_legend_attributes(self, long_df):
    method test_legend_unfilled (line 2288) | def test_legend_unfilled(self, long_df):
    method test_err_kws (line 2298) | def test_err_kws(self, fill):
    method test_vs_catplot (line 2330) | def test_vs_catplot(self, long_df, wide_df, null_df, flat_series, kwar...
    method test_errwidth_deprecation (line 2354) | def test_errwidth_deprecation(self):
    method test_errcolor_deprecation (line 2363) | def test_errcolor_deprecation(self):
    method test_capsize_as_none_deprecation (line 2372) | def test_capsize_as_none_deprecation(self):
    method test_hue_implied_by_palette_deprecation (line 2380) | def test_hue_implied_by_palette_deprecation(self):
  class TestPointPlot (line 2393) | class TestPointPlot(SharedAggTests):
    method get_last_color (line 2397) | def get_last_color(self, ax):
    method test_single_var (line 2403) | def test_single_var(self, orient):
    method test_wide_df (line 2411) | def test_wide_df(self, wide_df, orient):
    method test_vector_orient (line 2427) | def test_vector_orient(self, orient):
    method test_xy_vertical (line 2441) | def test_xy_vertical(self):
    method test_xy_horizontal (line 2448) | def test_xy_horizontal(self):
    method test_xy_with_na_grouper (line 2455) | def test_xy_with_na_grouper(self):
    method test_xy_with_na_value (line 2465) | def test_xy_with_na_value(self):
    method test_hue (line 2475) | def test_hue(self):
    method test_wide_data_is_joined (line 2484) | def test_wide_data_is_joined(self, wide_df):
    method test_xy_native_scale (line 2489) | def test_xy_native_scale(self):
    method test_estimate (line 2500) | def test_estimate(self, long_df, estimator):
    method test_weighted_estimate (line 2510) | def test_weighted_estimate(self, long_df):
    method test_estimate_log_transform (line 2517) | def test_estimate_log_transform(self, long_df):
    method test_errorbars (line 2525) | def test_errorbars(self, long_df):
    method test_marker_linestyle (line 2538) | def test_marker_linestyle(self):
    method test_markers_linestyles_single (line 2546) | def test_markers_linestyles_single(self):
    method test_markers_linestyles_mapped (line 2554) | def test_markers_linestyles_mapped(self):
    method test_dodge_boolean (line 2569) | def test_dodge_boolean(self):
    method test_dodge_float (line 2579) | def test_dodge_float(self):
    method test_dodge_log_scale (line 2589) | def test_dodge_log_scale(self):
    method test_err_kws (line 2601) | def test_err_kws(self):
    method test_err_kws_inherited (line 2610) | def test_err_kws_inherited(self):
    method test_legend_contents (line 2623) | def test_legend_contents(self):
    method test_legend_set_props (line 2640) | def test_legend_set_props(self):
    method test_legend_synced_props (line 2655) | def test_legend_synced_props(self):
    method test_vs_catplot (line 2692) | def test_vs_catplot(self, long_df, wide_df, null_df, flat_series, kwar...
    method test_legend_disabled (line 2716) | def test_legend_disabled(self, long_df):
    method test_join_deprecation (line 2721) | def test_join_deprecation(self):
    method test_scale_deprecation (line 2727) | def test_scale_deprecation(self):
    method test_layered_plot_clipping (line 2737) | def test_layered_plot_clipping(self):
  class TestCountPlot (line 2747) | class TestCountPlot:
    method test_empty (line 2749) | def test_empty(self):
    method test_labels_long (line 2757) | def test_labels_long(self, long_df):
    method test_wide_data (line 2772) | def test_wide_data(self, wide_df):
    method test_flat_series (line 2782) | def test_flat_series(self):
    method test_x_series (line 2794) | def test_x_series(self):
    method test_y_series (line 2806) | def test_y_series(self):
    method test_hue_redundant (line 2818) | def test_hue_redundant(self):
    method test_hue_dodged (line 2832) | def test_hue_dodged(self):
    method test_stat (line 2851) | def test_stat(self, long_df, stat):
    method test_xy_error (line 2862) | def test_xy_error(self, long_df):
    method test_legend_numeric_auto (line 2867) | def test_legend_numeric_auto(self, long_df):
    method test_legend_disabled (line 2872) | def test_legend_disabled(self, long_df):
    method test_vs_catplot (line 2899) | def test_vs_catplot(self, long_df, wide_df, null_df, flat_series, kwar...
  class CategoricalFixture (line 2921) | class CategoricalFixture:
    method get_box_artists (line 2935) | def get_box_artists(self, ax):
  class TestCatPlot (line 2944) | class TestCatPlot(CategoricalFixture):
    method test_facet_organization (line 2946) | def test_facet_organization(self):
    method test_plot_elements (line 2960) | def test_plot_elements(self):
    method test_bad_plot_kind_error (line 3024) | def test_bad_plot_kind_error(self):
    method test_count_x_and_y (line 3029) | def test_count_x_and_y(self):
    method test_plot_colors (line 3034) | def test_plot_colors(self):
    method test_ax_kwarg_removal (line 3076) | def test_ax_kwarg_removal(self):
    method test_share_xy (line 3084) | def test_share_xy(self):
    method test_facetgrid_data (line 3130) | def test_facetgrid_data(self, long_df):
    method test_array_faceter (line 3139) | def test_array_faceter(self, long_df, var):
    method test_invalid_kind (line 3147) | def test_invalid_kind(self, long_df):
    method test_legend_with_auto (line 3152) | def test_legend_with_auto(self):
    method test_weights_warning (line 3160) | def test_weights_warning(self, long_df):
  class TestBeeswarm (line 3167) | class TestBeeswarm:
    method test_could_overlap (line 3169) | def test_could_overlap(self):
    method test_position_candidates (line 3180) | def test_position_candidates(self):
    method test_find_first_non_overlapping_candidate (line 3193) | def test_find_first_non_overlapping_candidate(self):
    method test_beeswarm (line 3202) | def test_beeswarm(self, long_df):
    method test_add_gutters (line 3217) | def test_add_gutters(self):
  class TestBoxPlotContainer (line 3232) | class TestBoxPlotContainer:
    method container (line 3235) | def container(self, wide_array):
    method test_repr (line 3241) | def test_repr(self, container, wide_array):
    method test_iteration (line 3246) | def test_iteration(self, container):
    method test_label (line 3251) | def test_label(self, container):
    method test_children (line 3257) | def test_children(self, container):

FILE: tests/test_distributions.py
  function get_contour_coords (line 43) | def get_contour_coords(c, filter_empty=False):
  function get_contour_color (line 55) | def get_contour_color(c):
  class TestDistPlot (line 67) | class TestDistPlot:
    method test_hist_bins (line 72) | def test_hist_bins(self):
    method test_elements (line 88) | def test_elements(self):
    method test_distplot_with_nans (line 128) | def test_distplot_with_nans(self):
  class SharedAxesLevelTests (line 146) | class SharedAxesLevelTests:
    method test_color (line 148) | def test_color(self, long_df, **kwargs):
  class TestRugPlot (line 164) | class TestRugPlot(SharedAxesLevelTests):
    method get_last_color (line 168) | def get_last_color(self, ax, **kwargs):
    method assert_rug_equal (line 172) | def assert_rug_equal(self, a, b):
    method test_long_data (line 177) | def test_long_data(self, long_df, variable):
    method test_bivariate_data (line 191) | def test_bivariate_data(self, long_df):
    method test_wide_vs_long_data (line 202) | def test_wide_vs_long_data(self, wide_df):
    method test_flat_vector (line 218) | def test_flat_vector(self, long_df):
    method test_datetime_data (line 225) | def test_datetime_data(self, long_df):
    method test_empty_data (line 231) | def test_empty_data(self):
    method test_a_deprecation (line 236) | def test_a_deprecation(self, flat_series):
    method test_axis_deprecation (line 247) | def test_axis_deprecation(self, flat_series, variable):
    method test_vertical_deprecation (line 257) | def test_vertical_deprecation(self, flat_series):
    method test_rug_data (line 267) | def test_rug_data(self, flat_array):
    method test_rug_colors (line 278) | def test_rug_colors(self, long_df):
    method test_expand_margins (line 291) | def test_expand_margins(self, flat_array):
    method test_multiple_rugs (line 308) | def test_multiple_rugs(self):
    method test_matplotlib_kwargs (line 318) | def test_matplotlib_kwargs(self, flat_series):
    method test_axis_labels (line 327) | def test_axis_labels(self, flat_series):
    method test_log_scale (line 333) | def test_log_scale(self, long_df):
  class TestKDEPlotUnivariate (line 348) | class TestKDEPlotUnivariate(SharedAxesLevelTests):
    method get_last_color (line 352) | def get_last_color(self, ax, fill=True):
    method test_color (line 360) | def test_color(self, long_df, fill):
    method test_long_vectors (line 377) | def test_long_vectors(self, long_df, variable):
    method test_wide_vs_long_data (line 396) | def test_wide_vs_long_data(self, wide_df):
    method test_flat_vector (line 406) | def test_flat_vector(self, long_df):
    method test_empty_data (line 413) | def test_empty_data(self):
    method test_singular_data (line 418) | def test_singular_data(self):
    method test_variable_assignment (line 438) | def test_variable_assignment(self, long_df):
    method test_vertical_deprecation (line 449) | def test_vertical_deprecation(self, long_df):
    method test_bw_deprecation (line 459) | def test_bw_deprecation(self, long_df):
    method test_kernel_deprecation (line 469) | def test_kernel_deprecation(self, long_df):
    method test_shade_deprecation (line 479) | def test_shade_deprecation(self, long_df):
    method test_hue_colors (line 491) | def test_hue_colors(self, long_df, multiple):
    method test_hue_stacking (line 509) | def test_hue_stacking(self, long_df):
    method test_hue_filling (line 533) | def test_hue_filling(self, long_df):
    method test_fill_default (line 557) | def test_fill_default(self, long_df, multiple):
    method test_fill_nondefault (line 566) | def test_fill_nondefault(self, long_df, multiple):
    method test_color_cycle_interaction (line 577) | def test_color_cycle_interaction(self, flat_series):
    method test_artist_color (line 603) | def test_artist_color(self, long_df, fill):
    method test_datetime_scale (line 625) | def test_datetime_scale(self, long_df):
    method test_multiple_argument_check (line 632) | def test_multiple_argument_check(self, long_df):
    method test_cut (line 637) | def test_cut(self, rng):
    method test_clip (line 656) | def test_clip(self, rng):
    method test_line_is_density (line 668) | def test_line_is_density(self, long_df):
    method test_cumulative (line 675) | def test_cumulative(self, long_df):
    method test_cumulative_requires_scipy (line 683) | def test_cumulative_requires_scipy(self, long_df):
    method test_common_norm (line 688) | def test_common_norm(self, long_df):
    method test_common_grid (line 709) | def test_common_grid(self, long_df):
    method test_bw_method (line 734) | def test_bw_method(self, long_df):
    method test_bw_adjust (line 753) | def test_bw_adjust(self, long_df):
    method test_log_scale_implicit (line 772) | def test_log_scale_implicit(self, rng):
    method test_log_scale_explicit (line 792) | def test_log_scale_explicit(self, rng):
    method test_log_scale_with_hue (line 818) | def test_log_scale_with_hue(self, rng):
    method test_log_scale_normalization (line 824) | def test_log_scale_normalization(self, rng):
    method test_weights (line 832) | def test_weights(self):
    method test_weight_norm (line 846) | def test_weight_norm(self, rng):
    method test_sticky_edges (line 859) | def test_sticky_edges(self, long_df):
    method test_line_kws (line 871) | def test_line_kws(self, flat_array):
    method test_input_checking (line 880) | def test_input_checking(self, long_df):
    method test_axis_labels (line 886) | def test_axis_labels(self, long_df):
    method test_legend (line 898) | def test_legend(self, long_df):
    method test_replaced_kws (line 923) | def test_replaced_kws(self, long_df):
  class TestKDEPlotBivariate (line 928) | class TestKDEPlotBivariate:
    method test_long_vectors (line 930) | def test_long_vectors(self, long_df):
    method test_singular_data (line 947) | def test_singular_data(self):
    method test_fill_artists (line 966) | def test_fill_artists(self, long_df):
    method test_common_norm (line 979) | def test_common_norm(self, rng):
    method test_log_scale (line 994) | def test_log_scale(self, rng):
    method test_bandwidth (line 1022) | def test_bandwidth(self, rng):
    method test_weights (line 1039) | def test_weights(self, rng):
    method test_hue_ignores_cmap (line 1056) | def test_hue_ignores_cmap(self, long_df):
    method test_contour_line_colors (line 1063) | def test_contour_line_colors(self, long_df):
    method test_contour_line_cmap (line 1071) | def test_contour_line_cmap(self, long_df):
    method test_contour_fill_colors (line 1080) | def test_contour_fill_colors(self, long_df):
    method test_colorbar (line 1094) | def test_colorbar(self, long_df):
    method test_levels_and_thresh (line 1099) | def test_levels_and_thresh(self, long_df):
    method test_quantile_to_level (line 1131) | def test_quantile_to_level(self, rng):
    method test_input_checking (line 1140) | def test_input_checking(self, long_df):
  class TestHistPlotUnivariate (line 1146) | class TestHistPlotUnivariate(SharedAxesLevelTests):
    method get_last_color (line 1150) | def get_last_color(self, ax, element="bars", fill=True):
    method test_color (line 1171) | def test_color(self, long_df, element, fill):
    method test_long_vectors (line 1178) | def test_long_vectors(self, long_df, variable):
    method test_wide_vs_long_data (line 1195) | def test_wide_vs_long_data(self, wide_df):
    method test_flat_vector (line 1208) | def test_flat_vector(self, long_df):
    method test_empty_data (line 1219) | def test_empty_data(self):
    method test_variable_assignment (line 1224) | def test_variable_assignment(self, long_df):
    method test_hue_fill_colors (line 1236) | def test_hue_fill_colors(self, long_df, multiple, element):
    method test_hue_stack (line 1260) | def test_hue_stack(self, long_df):
    method test_hue_fill (line 1281) | def test_hue_fill(self, long_df):
    method test_hue_dodge (line 1304) | def test_hue_dodge(self, long_df):
    method test_hue_as_numpy_dodged (line 1324) | def test_hue_as_numpy_dodged(self, long_df):
    method test_multiple_input_check (line 1335) | def test_multiple_input_check(self, flat_series):
    method test_element_input_check (line 1340) | def test_element_input_check(self, flat_series):
    method test_count_stat (line 1345) | def test_count_stat(self, flat_series):
    method test_density_stat (line 1351) | def test_density_stat(self, flat_series):
    method test_density_stat_common_norm (line 1358) | def test_density_stat_common_norm(self, long_df):
    method test_density_stat_unique_norm (line 1368) | def test_density_stat_unique_norm(self, long_df):
    method height_norm_arg (line 1385) | def height_norm_arg(self, request):
    method test_probability_stat (line 1388) | def test_probability_stat(self, flat_series, height_norm_arg):
    method test_probability_stat_common_norm (line 1394) | def test_probability_stat_common_norm(self, long_df, height_norm_arg):
    method test_probability_stat_unique_norm (line 1403) | def test_probability_stat_unique_norm(self, long_df, height_norm_arg):
    method test_percent_stat (line 1417) | def test_percent_stat(self, flat_series):
    method test_common_bins (line 1423) | def test_common_bins(self, long_df):
    method test_unique_bins (line 1436) | def test_unique_bins(self, wide_df):
    method test_range_with_inf (line 1449) | def test_range_with_inf(self, rng):
    method test_weights_with_missing (line 1456) | def test_weights_with_missing(self, null_df):
    method test_weight_norm (line 1464) | def test_weight_norm(self, rng):
    method test_discrete (line 1479) | def test_discrete(self, long_df):
    method test_discrete_categorical_default (line 1491) | def test_discrete_categorical_default(self, long_df):
    method test_categorical_yaxis_inversion (line 1497) | def test_categorical_yaxis_inversion(self, long_df):
    method test_datetime_scale (line 1503) | def test_datetime_scale(self, long_df):
    method test_kde (line 1511) | def test_kde(self, flat_series, stat):
    method test_kde_with_hue (line 1528) | def test_kde_with_hue(self, long_df, stat, multiple):
    method test_kde_default_cut (line 1552) | def test_kde_default_cut(self, flat_series):
    method test_kde_hue (line 1559) | def test_kde_hue(self, long_df):
    method test_kde_yaxis (line 1569) | def test_kde_yaxis(self, flat_series):
    method test_kde_line_kws (line 1579) | def test_kde_line_kws(self, flat_series):
    method test_kde_singular_data (line 1585) | def test_kde_singular_data(self):
    method test_element_default (line 1597) | def test_element_default(self, long_df):
    method test_bars_no_fill (line 1609) | def test_bars_no_fill(self, flat_series):
    method test_step_fill (line 1617) | def test_step_fill(self, flat_series):
    method test_poly_fill (line 1638) | def test_poly_fill(self, flat_series):
    method test_poly_no_fill (line 1656) | def test_poly_no_fill(self, flat_series):
    method test_step_no_fill (line 1673) | def test_step_no_fill(self, flat_series):
    method test_step_fill_xy (line 1691) | def test_step_fill_xy(self, flat_series):
    method test_step_no_fill_xy (line 1703) | def test_step_no_fill_xy(self, flat_series):
    method test_weighted_histogram (line 1715) | def test_weighted_histogram(self):
    method test_weights_with_auto_bins (line 1722) | def test_weights_with_auto_bins(self, long_df):
    method test_shrink (line 1728) | def test_shrink(self, long_df):
    method test_log_scale_explicit (line 1746) | def test_log_scale_explicit(self, rng):
    method test_log_scale_implicit (line 1755) | def test_log_scale_implicit(self, rng):
    method test_log_scale_dodge (line 1767) | def test_log_scale_dodge(self, rng):
    method test_log_scale_kde (line 1776) | def test_log_scale_kde(self, rng):
    method test_auto_linewidth (line 1787) | def test_auto_linewidth(self, flat_series, fill):
    method test_bar_kwargs (line 1816) | def test_bar_kwargs(self, flat_series):
    method test_step_fill_kwargs (line 1825) | def test_step_fill_kwargs(self, flat_series):
    method test_step_line_kwargs (line 1834) | def test_step_line_kwargs(self, flat_series):
    method test_label (line 1843) | def test_label(self, flat_series):
    method test_default_color_scout_cleanup (line 1850) | def test_default_color_scout_cleanup(self, flat_series):
  class TestHistPlotBivariate (line 1856) | class TestHistPlotBivariate:
    method test_mesh (line 1858) | def test_mesh(self, long_df):
    method test_mesh_with_hue (line 1876) | def test_mesh_with_hue(self, long_df):
    method test_mesh_with_hue_unique_bins (line 1899) | def test_mesh_with_hue_unique_bins(self, long_df):
    method test_mesh_with_col_unique_bins (line 1921) | def test_mesh_with_col_unique_bins(self, long_df):
    method test_mesh_log_scale (line 1943) | def test_mesh_log_scale(self, rng):
    method test_mesh_thresh (line 1961) | def test_mesh_thresh(self, long_df):
    method test_mesh_sticky_edges (line 1974) | def test_mesh_sticky_edges(self, long_df):
    method test_mesh_common_norm (line 1987) | def test_mesh_common_norm(self, long_df):
    method test_mesh_unique_norm (line 2007) | def test_mesh_unique_norm(self, long_df):
    method test_mesh_normalization (line 2028) | def test_mesh_normalization(self, long_df, stat):
    method test_mesh_colors (line 2038) | def test_mesh_colors(self, long_df):
    method test_color_limits (line 2062) | def test_color_limits(self, long_df):
    method test_hue_color_limits (line 2090) | def test_hue_color_limits(self, long_df):
    method test_colorbar (line 2132) | def test_colorbar(self, long_df):
  class TestECDFPlotUnivariate (line 2143) | class TestECDFPlotUnivariate(SharedAxesLevelTests):
    method get_last_color (line 2147) | def get_last_color(self, ax):
    method test_long_vectors (line 2152) | def test_long_vectors(self, long_df, variable):
    method test_hue (line 2171) | def test_hue(self, long_df):
    method test_line_kwargs (line 2178) | def test_line_kwargs(self, long_df):
    method test_drawstyle (line 2191) | def test_drawstyle(self, flat_series, data_var):
    method test_proportion_limits (line 2200) | def test_proportion_limits(self, flat_series, data_var, stat_var):
    method test_proportion_limits_complementary (line 2212) | def test_proportion_limits_complementary(self, flat_series, data_var, ...
    method test_proportion_count (line 2224) | def test_proportion_count(self, flat_series, data_var, stat_var):
    method test_weights (line 2234) | def test_weights(self):
    method test_bivariate_error (line 2240) | def test_bivariate_error(self, long_df):
    method test_log_scale (line 2245) | def test_log_scale(self, long_df):
  class TestDisPlot (line 2259) | class TestDisPlot:
    method test_versus_single_histplot (line 2282) | def test_versus_single_histplot(self, long_df, kwargs):
    method test_versus_single_kdeplot (line 2312) | def test_versus_single_kdeplot(self, long_df, kwargs):
    method test_versus_single_ecdfplot (line 2340) | def test_versus_single_ecdfplot(self, long_df, kwargs):
    method test_with_rug (line 2361) | def test_with_rug(self, long_df, kwargs):
    method test_facets (line 2379) | def test_facets(self, long_df, facet_var):
    method test_facet_multiple (line 2396) | def test_facet_multiple(self, long_df, multiple):
    method test_ax_warning (line 2412) | def test_ax_warning(self, long_df):
    method test_array_faceting (line 2419) | def test_array_faceting(self, long_df, key):
    method test_legend (line 2428) | def test_legend(self, long_df):
    method test_empty (line 2433) | def test_empty(self):
    method test_bivariate_ecdf_error (line 2438) | def test_bivariate_ecdf_error(self, long_df):
    method test_bivariate_kde_norm (line 2443) | def test_bivariate_kde_norm(self, rng):
    method test_bivariate_hist_norm (line 2464) | def test_bivariate_hist_norm(self, rng):
    method test_facetgrid_data (line 2479) | def test_facetgrid_data(self, long_df):
  function integrate (line 2493) | def integrate(y, x):

FILE: tests/test_docstrings.py
  class ExampleClass (line 12) | class ExampleClass:
    method example_method (line 13) | def example_method(self):
  function example_func (line 24) | def example_func():
  class TestDocstringComponents (line 35) | class TestDocstringComponents:
    method test_from_dict (line 37) | def test_from_dict(self):
    method test_from_nested_components (line 42) | def test_from_nested_components(self):
    method test_from_function (line 48) | def test_from_function(self):
    method test_from_method (line 53) | def test_from_method(self):

FILE: tests/test_matrix.py
  class TestHeatmap (line 33) | class TestHeatmap:
    method test_ndarray_input (line 47) | def test_ndarray_input(self):
    method test_array_like_input (line 59) | def test_array_like_input(self):
    method test_df_input (line 77) | def test_df_input(self):
    method test_df_multindex_input (line 89) | def test_df_multindex_input(self):
    method test_mask_input (line 110) | def test_mask_input(self, dtype):
    method test_mask_limits (line 121) | def test_mask_limits(self):
    method test_default_vlims (line 140) | def test_default_vlims(self):
    method test_robust_vlims (line 146) | def test_robust_vlims(self):
    method test_custom_sequential_vlims (line 155) | def test_custom_sequential_vlims(self):
    method test_custom_diverging_vlims (line 165) | def test_custom_diverging_vlims(self):
    method test_array_with_nans (line 176) | def test_array_with_nans(self):
    method test_mask (line 188) | def test_mask(self):
    method test_custom_cmap (line 202) | def test_custom_cmap(self):
    method test_centered_vlims (line 209) | def test_centered_vlims(self):
    method test_default_colors (line 219) | def test_default_colors(self):
    method test_custom_vlim_colors (line 228) | def test_custom_vlim_colors(self):
    method test_custom_center_colors (line 236) | def test_custom_center_colors(self):
    method test_cmap_with_properties (line 244) | def test_cmap_with_properties(self):
    method test_explicit_none_norm (line 283) | def test_explicit_none_norm(self):
    method test_ticklabels_off (line 297) | def test_ticklabels_off(self):
    method test_custom_ticklabels (line 305) | def test_custom_ticklabels(self):
    method test_custom_ticklabel_interval (line 315) | def test_custom_ticklabel_interval(self):
    method test_heatmap_annotation (line 331) | def test_heatmap_annotation(self):
    method test_heatmap_annotation_overwrite_kws (line 339) | def test_heatmap_annotation_overwrite_kws(self):
    method test_heatmap_annotation_with_mask (line 349) | def test_heatmap_annotation_with_mask(self):
    method test_heatmap_annotation_mesh_colors (line 361) | def test_heatmap_annotation_mesh_colors(self):
    method test_heatmap_annotation_other_data (line 369) | def test_heatmap_annotation_other_data(self):
    method test_heatmap_annotation_different_shapes (line 379) | def test_heatmap_annotation_different_shapes(self):
    method test_heatmap_annotation_with_limited_ticklabels (line 385) | def test_heatmap_annotation_with_limited_ticklabels(self):
    method test_heatmap_cbar (line 391) | def test_heatmap_cbar(self):
    method test_heatmap_axes (line 408) | def test_heatmap_axes(self):
    method test_heatmap_ticklabel_rotation (line 423) | def test_heatmap_ticklabel_rotation(self):
    method test_heatmap_inner_lines (line 451) | def test_heatmap_inner_lines(self):
    method test_square_aspect (line 459) | def test_square_aspect(self):
    method test_mask_validation (line 464) | def test_mask_validation(self):
    method test_missing_data_mask (line 478) | def test_missing_data_mask(self):
    method test_cbar_ticks (line 489) | def test_cbar_ticks(self):
  class TestDendrogram (line 498) | class TestDendrogram:
    method test_ndarray_input (line 526) | def test_ndarray_input(self):
    method test_df_input (line 542) | def test_df_input(self):
    method test_df_multindex_input (line 558) | def test_df_multindex_input(self):
    method test_axis0_input (line 577) | def test_axis0_input(self):
    method test_rotate_input (line 594) | def test_rotate_input(self):
    method test_rotate_axis0_input (line 607) | def test_rotate_axis0_input(self):
    method test_custom_linkage (line 615) | def test_custom_linkage(self):
    method test_label_false (line 634) | def test_label_false(self):
    method test_linkage_scipy (line 645) | def test_linkage_scipy(self):
    method test_fastcluster_other_method (line 660) | def test_fastcluster_other_method(self):
    method test_fastcluster_non_euclidean (line 671) | def test_fastcluster_non_euclidean(self):
    method test_dendrogram_plot (line 682) | def test_dendrogram_plot(self):
    method test_dendrogram_rotate (line 695) | def test_dendrogram_rotate(self):
    method test_dendrogram_ticklabel_rotation (line 712) | def test_dendrogram_ticklabel_rotation(self):
  class TestClustermap (line 741) | class TestClustermap:
    method test_ndarray_input (line 780) | def test_ndarray_input(self):
    method test_df_input (line 787) | def test_df_input(self):
    method test_corr_df_input (line 791) | def test_corr_df_input(self):
    method test_pivot_input (line 798) | def test_pivot_input(self):
    method test_colors_input (line 810) | def test_colors_input(self):
    method test_categorical_colors_input (line 822) | def test_categorical_colors_input(self):
    method test_nested_colors_input (line 842) | def test_nested_colors_input(self):
    method test_colors_input_custom_cmap (line 856) | def test_colors_input_custom_cmap(self):
    method test_z_score (line 869) | def test_z_score(self):
    method test_z_score_axis0 (line 878) | def test_z_score_axis0(self):
    method test_standard_scale (line 889) | def test_standard_scale(self):
    method test_standard_scale_axis0 (line 898) | def test_standard_scale_axis0(self):
    method test_z_score_standard_scale (line 909) | def test_z_score_standard_scale(self):
    method test_color_list_to_matrix_and_cmap (line 916) | def test_color_list_to_matrix_and_cmap(self):
    method test_nested_color_list_to_matrix_and_cmap (line 925) | def test_nested_color_list_to_matrix_and_cmap(self):
    method test_color_list_to_matrix_and_cmap_axis1 (line 936) | def test_color_list_to_matrix_and_cmap_axis1(self):
    method test_color_list_to_matrix_and_cmap_different_sizes (line 944) | def test_color_list_to_matrix_and_cmap_different_sizes(self):
    method test_savefig (line 950) | def test_savefig(self):
    method test_plot_dendrograms (line 956) | def test_plot_dendrograms(self):
    method test_cluster_false (line 969) | def test_cluster_false(self):
    method test_row_col_colors (line 985) | def test_row_col_colors(self):
    method test_cluster_false_row_col_colors (line 995) | def test_cluster_false_row_col_colors(self):
    method test_row_col_colors_df (line 1015) | def test_row_col_colors_df(self):
    method test_row_col_colors_df_shuffled (line 1038) | def test_row_col_colors_df_shuffled(self):
    method test_row_col_colors_df_missing (line 1061) | def test_row_col_colors_df_missing(self):
    method test_row_col_colors_df_one_axis (line 1076) | def test_row_col_colors_df_one_axis(self):
    method test_row_col_colors_series (line 1105) | def test_row_col_colors_series(self):
    method test_row_col_colors_series_shuffled (line 1122) | def test_row_col_colors_series_shuffled(self):
    method test_row_col_colors_series_missing (line 1146) | def test_row_col_colors_series_missing(self):
    method test_row_col_colors_ignore_heatmap_kwargs (line 1160) | def test_row_col_colors_ignore_heatmap_kwargs(self):
    method test_row_col_colors_raise_on_mixed_index_types (line 1179) | def test_row_col_colors_raise_on_mixed_index_types(self):
    method test_mask_reorganization (line 1195) | def test_mask_reorganization(self):
    method test_ticklabel_reorganization (line 1211) | def test_ticklabel_reorganization(self):
    method test_noticklabels (line 1230) | def test_noticklabels(self):
    method test_size_ratios (line 1243) | def test_size_ratios(self):
    method test_cbar_pos (line 1305) | def test_cbar_pos(self):
    method test_square_warning (line 1320) | def test_square_warning(self):
    method test_clustermap_annotation (line 1333) | def test_clustermap_annotation(self):
    method test_tree_kws (line 1343) | def test_tree_kws(self):
  function test_required_scipy_errors (line 1354) | def test_required_scipy_errors():

FILE: tests/test_miscplot.py
  class TestPalPlot (line 8) | class TestPalPlot:
    method test_palplot_size (line 10) | def test_palplot_size(self):
  class TestDogPlot (line 28) | class TestDogPlot:
    method test_dogplot (line 31) | def test_dogplot(self):

FILE: tests/test_objects.py
  function test_objects_namespace (line 9) | def test_objects_namespace():

FILE: tests/test_palettes.py
  class TestColorPalettes (line 14) | class TestColorPalettes:
    method test_current_palette (line 16) | def test_current_palette(self):
    method test_palette_context (line 23) | def test_palette_context(self):
    method test_big_palette_context (line 33) | def test_big_palette_context(self):
    method test_palette_size (line 47) | def test_palette_size(self):
    method test_seaborn_palettes (line 64) | def test_seaborn_palettes(self):
    method test_hls_palette (line 73) | def test_hls_palette(self):
    method test_husl_palette (line 83) | def test_husl_palette(self):
    method test_mpl_palette (line 93) | def test_mpl_palette(self):
    method test_mpl_dark_palette (line 105) | def test_mpl_dark_palette(self):
    method test_bad_palette_name (line 115) | def test_bad_palette_name(self):
    method test_terrible_palette_name (line 120) | def test_terrible_palette_name(self):
    method test_bad_palette_colors (line 125) | def test_bad_palette_colors(self):
    method test_palette_desat (line 131) | def test_palette_desat(self):
    method test_palette_is_list_of_tuples (line 138) | def test_palette_is_list_of_tuples(self):
    method test_palette_cycles (line 148) | def test_palette_cycles(self):
    method test_hls_values (line 154) | def test_hls_values(self):
    method test_husl_values (line 171) | def test_husl_values(self):
    method test_cbrewer_qual (line 188) | def test_cbrewer_qual(self):
    method test_mpl_reversal (line 198) | def test_mpl_reversal(self):
    method test_rgb_from_hls (line 204) | def test_rgb_from_hls(self):
    method test_rgb_from_husl (line 211) | def test_rgb_from_husl(self):
    method test_rgb_from_xkcd (line 224) | def test_rgb_from_xkcd(self):
    method test_light_palette (line 231) | def test_light_palette(self):
    method test_dark_palette (line 257) | def test_dark_palette(self):
    method test_diverging_palette (line 283) | def test_diverging_palette(self):
    method test_blend_palette (line 305) | def test_blend_palette(self):
    method test_cubehelix_against_matplotlib (line 317) | def test_cubehelix_against_matplotlib(self):
    method test_cubehelix_n_colors (line 327) | def test_cubehelix_n_colors(self):
    method test_cubehelix_reverse (line 333) | def test_cubehelix_reverse(self):
    method test_cubehelix_cmap (line 339) | def test_cubehelix_cmap(self):
    method test_cubehelix_code (line 353) | def test_cubehelix_code(self):
    method test_xkcd_palette (line 378) | def test_xkcd_palette(self):
    method test_crayon_palette (line 386) | def test_crayon_palette(self):
    method test_color_codes (line 394) | def test_color_codes(self):
    method test_as_hex (line 407) | def test_as_hex(self):
    method test_preserved_palette_length (line 413) | def test_preserved_palette_length(self):
    method test_html_repr (line 419) | def test_html_repr(self):
    method test_colormap_display_patch (line 426) | def test_colormap_display_patch(self):

FILE: tests/test_rcmod.py
  function has_verdana (line 10) | def has_verdana():
  class RCParamFixtures (line 33) | class RCParamFixtures:
    method reset_params (line 36) | def reset_params(self):
    method flatten_list (line 40) | def flatten_list(self, orig_list):
    method assert_rc_params (line 46) | def assert_rc_params(self, params):
    method assert_rc_params_equal (line 58) | def assert_rc_params_equal(self, params1, params2):
  class TestAxesStyle (line 73) | class TestAxesStyle(RCParamFixtures):
    method test_default_return (line 77) | def test_default_return(self):
    method test_key_usage (line 82) | def test_key_usage(self):
    method test_bad_style (line 88) | def test_bad_style(self):
    method test_rc_override (line 93) | def test_rc_override(self):
    method test_set_style (line 100) | def test_set_style(self):
    method test_style_context_manager (line 108) | def test_style_context_manager(self):
    method test_style_context_independence (line 124) | def test_style_context_independence(self):
    method test_set_rc (line 128) | def test_set_rc(self):
    method test_set_with_palette (line 134) | def test_set_with_palette(self):
    method test_reset_defaults (line 157) | def test_reset_defaults(self):
    method test_reset_orig (line 163) | def test_reset_orig(self):
    method test_set_is_alias (line 169) | def test_set_is_alias(self):
  class TestPlottingContext (line 183) | class TestPlottingContext(RCParamFixtures):
    method test_default_return (line 187) | def test_default_return(self):
    method test_key_usage (line 192) | def test_key_usage(self):
    method test_bad_context (line 199) | def test_bad_context(self):
    method test_font_scale (line 204) | def test_font_scale(self):
    method test_rc_override (line 219) | def test_rc_override(self):
    method test_set_context (line 227) | def test_set_context(self):
    method test_context_context_manager (line 235) | def test_context_context_manager(self):
  class TestPalette (line 252) | class TestPalette(RCParamFixtures):
    method test_set_palette (line 254) | def test_set_palette(self):
  class TestFonts (line 273) | class TestFonts(RCParamFixtures):
    method test_set_font (line 278) | def test_set_font(self):
    method test_set_serif_font (line 289) | def test_set_serif_font(self):
    method test_different_sans_serif (line 301) | def test_different_sans_serif(self):

FILE: tests/test_regression.py
  class TestLinearPlotter (line 24) | class TestLinearPlotter:
    method test_establish_variables_from_frame (line 35) | def test_establish_variables_from_frame(self):
    method test_establish_variables_from_series (line 43) | def test_establish_variables_from_series(self):
    method test_establish_variables_from_array (line 51) | def test_establish_variables_from_array(self):
    method test_establish_variables_from_lists (line 61) | def test_establish_variables_from_lists(self):
    method test_establish_variables_from_mix (line 71) | def test_establish_variables_from_mix(self):
    method test_establish_variables_from_bad (line 79) | def test_establish_variables_from_bad(self):
    method test_dropna (line 85) | def test_dropna(self):
  class TestRegressionPlotter (line 98) | class TestRegressionPlotter:
    method test_variables_from_frame (line 121) | def test_variables_from_frame(self):
    method test_variables_from_series (line 130) | def test_variables_from_series(self):
    method test_variables_from_mix (line 139) | def test_variables_from_mix(self):
    method test_variables_must_be_1d (line 147) | def test_variables_must_be_1d(self):
    method test_dropna (line 156) | def test_dropna(self):
    method test_singleton (line 168) | def test_singleton(self, x, y):
    method test_ci (line 172) | def test_ci(self):
    method test_fast_regression (line 187) | def test_fast_regression(self):
    method test_regress_poly (line 201) | def test_regress_poly(self):
    method test_statsmodels_missing_errors (line 216) | def test_statsmodels_missing_errors(self, long_df, option):
    method test_regress_logx (line 220) | def test_regress_logx(self):
    method test_regress_n_boot (line 235) | def test_regress_n_boot(self):
    method test_regress_without_boots

[
  {
    "path": ".github/CONTRIBUTING.md",
    "chars": 2323,
    "preview": "Contributing to seaborn\n=======================\n\nGeneral support\n---------------\n\nGeneral support questions (\"how do I d"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 218,
    "preview": "version: 2\nupdates:\n  # Maintain dependencies for GitHub Actions\n  - package-ecosystem: \"github-actions\"\n    directory: "
  },
  {
    "path": ".github/workflows/ci.yaml",
    "chars": 2899,
    "preview": "name: CI\n\non:\n  push:\n    branches: [master, v0.*]\n  pull_request:\n    branches: master\n  schedule:\n    - cron:  '0 6 * "
  },
  {
    "path": ".gitignore",
    "chars": 156,
    "preview": "*.pyc\n*.sw*\nbuild/\n.ipynb_checkpoints/\ndist/\nseaborn.egg-info/\n.cache/\n.coverage\ncover/\nhtmlcov/\n.idea/\n.vscode/\n.pytest"
  },
  {
    "path": ".pre-commit-config.yaml",
    "chars": 540,
    "preview": "repos:\n-   repo: https://github.com/pre-commit/pre-commit-hooks\n    rev: v4.3.0\n    hooks:\n    -   id: check-yaml\n    - "
  },
  {
    "path": "CITATION.cff",
    "chars": 512,
    "preview": "cff-version: 1.2.0\nmessage: \"If seaborn is integral to a scientific publication, please cite the following paper:\"\nprefe"
  },
  {
    "path": "LICENSE.md",
    "chars": 1491,
    "preview": "Copyright (c) 2012-2023, Michael L. Waskom\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with"
  },
  {
    "path": "Makefile",
    "chars": 219,
    "preview": "export SHELL := /bin/bash\n\ntest:\n\tpytest -n auto --cov=seaborn --cov=tests --cov-config=setup.cfg tests\n\nlint:\n\tflake8 s"
  },
  {
    "path": "README.md",
    "chars": 3519,
    "preview": "<img src=\"https://raw.githubusercontent.com/mwaskom/seaborn/master/doc/_static/logo-wide-lightbg.svg\"><br>\n\n------------"
  },
  {
    "path": "SECURITY.md",
    "chars": 726,
    "preview": "# Security Policy\n\nIf you have discovered a security vulnerability in this project, please report it\nprivately. **Do not"
  },
  {
    "path": "ci/cache_datasets.py",
    "chars": 643,
    "preview": "\"\"\"\nCache test datasets before running tests / building docs.\n\nAvoids race conditions that would arise from parallelizat"
  },
  {
    "path": "ci/check_gallery.py",
    "chars": 348,
    "preview": "\"\"\"Execute the scripts that comprise the example gallery in the online docs.\"\"\"\nfrom glob import glob\nimport matplotlib."
  },
  {
    "path": "ci/deps_pinned.txt",
    "chars": 95,
    "preview": "numpy~=1.26.0\npandas~=2.0.0\nmatplotlib~=3.8.0\nscipy~=1.11.0\nstatsmodels~=0.14.0\npillow~=10.3.0\n"
  },
  {
    "path": "ci/getmsfonts.sh",
    "chars": 142,
    "preview": "echo ttf-mscorefonts-installer msttcorefonts/accepted-mscorefonts-eula select true | debconf-set-selections\napt-get inst"
  },
  {
    "path": "doc/.gitignore",
    "chars": 111,
    "preview": "*_files/\n_build/\ngenerated/\nexamples/\nexample_thumbs/*.png\ndocstrings/\ntutorial/\ntutorial/_images\ntutorial.rst\n"
  },
  {
    "path": "doc/Makefile",
    "chars": 6010,
    "preview": "# Makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS    =\nSPHINXBUILD "
  },
  {
    "path": "doc/README.md",
    "chars": 1156,
    "preview": "Building the seaborn docs\n=========================\n\nBuilding the docs requires additional dependencies; they can be ins"
  },
  {
    "path": "doc/_docstrings/FacetGrid.ipynb",
    "chars": 8383,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/JointGrid.ipynb",
    "chars": 6082,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/Makefile",
    "chars": 408,
    "preview": "rst_files := $(patsubst %.ipynb,../docstrings/%.rst,$(wildcard *.ipynb))\nexport MPLBACKEND := module://matplotlib_inline"
  },
  {
    "path": "doc/_docstrings/PairGrid.ipynb",
    "chars": 6566,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/axes_style.ipynb",
    "chars": 1924,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"dated-mother\",\n   \"metadata\": {\n    \"tag"
  },
  {
    "path": "doc/_docstrings/barplot.ipynb",
    "chars": 7093,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"6a6d582b-08c2-4fed-be56-afa1b986943a\",\n "
  },
  {
    "path": "doc/_docstrings/blend_palette.ipynb",
    "chars": 2146,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"8f97280e-cec8-42b2-a968-4fd4364594f8\",\n "
  },
  {
    "path": "doc/_docstrings/boxenplot.ipynb",
    "chars": 7029,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"882d215b-88d8-4b5e-ae7a-0e3f6bb53bad\",\n "
  },
  {
    "path": "doc/_docstrings/boxplot.ipynb",
    "chars": 5038,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"7edcf92f-6c11-4dc4-b684-118b3235d067\",\n "
  },
  {
    "path": "doc/_docstrings/catplot.ipynb",
    "chars": 4579,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"a8aa6a6a-f6c0-4a6b-9460-2056e58a2e13\",\n "
  },
  {
    "path": "doc/_docstrings/clustermap.ipynb",
    "chars": 3900,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"ffc1e1d9-fa74-4121-aa87-e1a8665e4c2b\",\n "
  },
  {
    "path": "doc/_docstrings/color_palette.ipynb",
    "chars": 5235,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/countplot.ipynb",
    "chars": 1949,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2fdf0f63-d515-4cb8-b3e0-62cac7852b12\",\n "
  },
  {
    "path": "doc/_docstrings/cubehelix_palette.ipynb",
    "chars": 4649,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"60aebc68-2c7c-4af5-a159-8421e1f94ba6\",\n "
  },
  {
    "path": "doc/_docstrings/dark_palette.ipynb",
    "chars": 2816,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"5cd1cbb8-ba1a-460b-8e3a-bc285867f1d1\",\n "
  },
  {
    "path": "doc/_docstrings/displot.ipynb",
    "chars": 5515,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/diverging_palette.ipynb",
    "chars": 3781,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"01295cb6-cc7a-4c6d-94cf-9b0e6cde9fa7\",\n "
  },
  {
    "path": "doc/_docstrings/ecdfplot.ipynb",
    "chars": 2957,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"Plot a univariate distribution alon"
  },
  {
    "path": "doc/_docstrings/heatmap.ipynb",
    "chars": 4373,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"987b9549-532e-4091-a6cf-007d1b23e825\",\n "
  },
  {
    "path": "doc/_docstrings/histplot.ipynb",
    "chars": 11278,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/hls_palette.ipynb",
    "chars": 3160,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"158cd1cf-6b30-4054-b32f-a166fcb883be\",\n "
  },
  {
    "path": "doc/_docstrings/husl_palette.ipynb",
    "chars": 3081,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"a6794650-f28f-40eb-95a7-3f0e5c4b332d\",\n "
  },
  {
    "path": "doc/_docstrings/jointplot.ipynb",
    "chars": 4753,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/kdeplot.ipynb",
    "chars": 7040,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/light_palette.ipynb",
    "chars": 2822,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"5cd1cbb8-ba1a-460b-8e3a-bc285867f1d1\",\n "
  },
  {
    "path": "doc/_docstrings/lineplot.ipynb",
    "chars": 10463,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/lmplot.ipynb",
    "chars": 3631,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"id\": \"034a9a5b-91ff-4ccc-932d-0f314e2cd6d2\",\n   \"metadata\": {},\n   \"source\""
  },
  {
    "path": "doc/_docstrings/move_legend.ipynb",
    "chars": 3953,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"8ec46ad8-bc4c-4ee0-9626-271088c702f9\",\n "
  },
  {
    "path": "doc/_docstrings/mpl_palette.ipynb",
    "chars": 2868,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"1d0d41d3-463c-4c6f-aa65-38131bdf3ddb\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Agg.ipynb",
    "chars": 3331,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"0d053943-66c9-410d-ad65-ce91f1c1ff48\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Area.ipynb",
    "chars": 3667,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Band.ipynb",
    "chars": 3481,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Bar.ipynb",
    "chars": 4384,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Bars.ipynb",
    "chars": 3985,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Count.ipynb",
    "chars": 2694,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"89113d6b-70b9-4ebe-9910-10a80eab246e\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Dash.ipynb",
    "chars": 3712,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"3227e585-7166-44e7-b0c2-8570e098102d\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Dodge.ipynb",
    "chars": 4544,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"4d44a940-db84-4e16-bc83-e67d08d6d56a\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Dot.ipynb",
    "chars": 4498,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Dots.ipynb",
    "chars": 3218,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Est.ipynb",
    "chars": 3810,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"57ececfa-0ae0-4acb-b85d-7c6a6ca8d3db\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Hist.ipynb",
    "chars": 5425,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"59690096-a0ad-4ff3-b82c-0258d724035a\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Jitter.ipynb",
    "chars": 4200,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"f2e5a85d-c710-492b-a4fc-09b45ae26471\",\n "
  },
  {
    "path": "doc/_docstrings/objects.KDE.ipynb",
    "chars": 6188,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"dcc1ae12-bba4-4de9-af8d-543b3d65b42b\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Line.ipynb",
    "chars": 4053,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Lines.ipynb",
    "chars": 2283,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Norm.ipynb",
    "chars": 2147,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"0bfee8b6-1e3e-499d-96ae-735a5c230b32\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Path.ipynb",
    "chars": 1997,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Paths.ipynb",
    "chars": 2384,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Perc.ipynb",
    "chars": 2826,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2d44a326-029b-47ff-b560-5f4b6a4bb73f\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Plot.add.ipynb",
    "chars": 6685,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"9252d5a5-8af1-4f99-b799-ee044329fb23\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Plot.config.ipynb",
    "chars": 4929,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"a38a6fed-51de-4dbc-8d5b-4971d06acf2e\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Plot.facet.ipynb",
    "chars": 5176,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"id\": \"fb8e120d-5dcf-483b-a0d1-74857d09ce7d\",\n   \"metadata\": {},\n   \"source\""
  },
  {
    "path": "doc/_docstrings/objects.Plot.label.ipynb",
    "chars": 5921,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"9252d5a5-8af1-4f99-b799-ee044329fb23\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Plot.layout.ipynb",
    "chars": 2814,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"9252d5a5-8af1-4f99-b799-ee044329fb23\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Plot.limit.ipynb",
    "chars": 2528,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"9252d5a5-8af1-4f99-b799-ee044329fb23\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Plot.on.ipynb",
    "chars": 5018,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"id\": \"fb8e120d-5dcf-483b-a0d1-74857d09ce7d\",\n   \"metadata\": {},\n   \"source\""
  },
  {
    "path": "doc/_docstrings/objects.Plot.pair.ipynb",
    "chars": 5338,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"id\": \"ac7814b6-1e2c-4f0e-991b-7fe78fca4346\",\n   \"metadata\": {},\n   \"source\""
  },
  {
    "path": "doc/_docstrings/objects.Plot.scale.ipynb",
    "chars": 7980,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"9252d5a5-8af1-4f99-b799-ee044329fb23\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Plot.share.ipynb",
    "chars": 2911,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"9252d5a5-8af1-4f99-b799-ee044329fb23\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Plot.theme.ipynb",
    "chars": 4299,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"9252d5a5-8af1-4f99-b799-ee044329fb23\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Range.ipynb",
    "chars": 3542,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2923956c-f141-4ecb-ab08-e819099f0fa9\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Shift.ipynb",
    "chars": 2151,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"2605c8d0-5872-4dff-9172-db81fac1cee1\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Stack.ipynb",
    "chars": 2087,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"87244f49-8cf2-4668-a556-a8c7828b31bf\",\n "
  },
  {
    "path": "doc/_docstrings/objects.Text.ipynb",
    "chars": 4452,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"cd1cdefe-b8c1-40b9-be31-006d52ec9f18\",\n "
  },
  {
    "path": "doc/_docstrings/pairplot.ipynb",
    "chars": 4898,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/plotting_context.ipynb",
    "chars": 2074,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"perceived-worry\",\n   \"metadata\": {\n    \""
  },
  {
    "path": "doc/_docstrings/pointplot.ipynb",
    "chars": 6558,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"43f842ee-44c9-476b-ab08-112d23e2effb\",\n "
  },
  {
    "path": "doc/_docstrings/regplot.ipynb",
    "chars": 5688,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"611aed40-d120-4fbf-b1e6-9712ed8167fc\",\n "
  },
  {
    "path": "doc/_docstrings/relplot.ipynb",
    "chars": 6740,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \"These examples will illustrate only some"
  },
  {
    "path": "doc/_docstrings/residplot.ipynb",
    "chars": 2518,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"776f8271-21ed-4707-a1ad-09d8c63ae95a\",\n "
  },
  {
    "path": "doc/_docstrings/rugplot.ipynb",
    "chars": 2928,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"Add a rug along one of the axes:\"\n "
  },
  {
    "path": "doc/_docstrings/scatterplot.ipynb",
    "chars": 7624,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/set_context.ipynb",
    "chars": 2101,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"thorough-equipment\",\n   \"metadata\": {\n  "
  },
  {
    "path": "doc/_docstrings/set_style.ipynb",
    "chars": 1713,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"practical-announcement\",\n   \"metadata\": "
  },
  {
    "path": "doc/_docstrings/set_theme.ipynb",
    "chars": 3596,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"flush-block\",\n   \"metadata\": {\n    \"tags"
  },
  {
    "path": "doc/_docstrings/stripplot.ipynb",
    "chars": 7312,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/swarmplot.ipynb",
    "chars": 7008,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"metadata\": {\n    \"tags\": [\n     \"hide\"\n    ]\n "
  },
  {
    "path": "doc/_docstrings/violinplot.ipynb",
    "chars": 8096,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": null,\n   \"id\": \"cc19031c-bc2f-4294-95ce-3a2d9b86f44d\",\n "
  },
  {
    "path": "doc/_static/copybutton.js",
    "chars": 2652,
    "preview": "// originally taken from scikit-learn's Sphinx theme\n$(document).ready(function() {\n    /* Add a [>>>] button on the top"
  },
  {
    "path": "doc/_static/css/custom.css",
    "chars": 2232,
    "preview": "/**** Overriding theme defaults ****/\n\nhtml[data-theme=light]{\n  --pst-color-primary: rgb(52, 54, 99);\n  --pst-color-sec"
  },
  {
    "path": "doc/_templates/autosummary/base.rst",
    "chars": 106,
    "preview": "{{ fullname | escape | underline}}\n\n.. currentmodule:: {{ module }}\n\n.. auto{{ objtype }}:: {{ objname }}\n"
  },
  {
    "path": "doc/_templates/autosummary/class.rst",
    "chars": 550,
    "preview": "{{ fullname | escape | underline}}\n\n.. currentmodule:: {{ module }}\n\n.. autoclass:: {{ objname }}\n\n   {% block methods %"
  },
  {
    "path": "doc/_templates/autosummary/object.rst",
    "chars": 98,
    "preview": "{{ fullname | escape | underline}}\n\n.. currentmodule:: {{ module }}\n\n.. autoclass:: {{ objname }}\n"
  },
  {
    "path": "doc/_templates/autosummary/plot.rst",
    "chars": 1043,
    "preview": "{{ fullname | escape | underline}}\n\n.. currentmodule:: {{ module }}\n\n.. autoclass:: {{ objname }}\n\n{% block methods %}\n\n"
  },
  {
    "path": "doc/_templates/autosummary/scale.rst",
    "chars": 149,
    "preview": "{{ fullname | escape | underline}}\n\n.. currentmodule:: {{ module }}\n\n.. autoclass:: {{ objname }}\n\n   .. automethod:: ti"
  },
  {
    "path": "doc/_templates/layout.html",
    "chars": 1377,
    "preview": "{% extends \"!layout.html\" %}\n\n{%- block footer %}\n<footer class=\"footer\" style=\"border-top: 1px solid #ccc; padding-top:"
  },
  {
    "path": "doc/_templates/version.html",
    "chars": 86,
    "preview": "<div id=\"version\" class=\"navbar-start-item\" style=\"color: #bbb\">\n{{ version }}\n</div>\n"
  },
  {
    "path": "doc/_tutorial/Makefile",
    "chars": 258,
    "preview": "rst_files := $(patsubst %.ipynb,../tutorial/%.rst,$(wildcard *.ipynb))\nexport MPLBACKEND := module://matplotlib_inline.b"
  },
  {
    "path": "doc/_tutorial/aesthetics.ipynb",
    "chars": 11990,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _aesthetics_tutorial:\\n\",\n    \"\\n\",\n "
  },
  {
    "path": "doc/_tutorial/axis_grids.ipynb",
    "chars": 19991,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _grid_tutorial:\\n\",\n    \"\\n\",\n    \".."
  },
  {
    "path": "doc/_tutorial/categorical.ipynb",
    "chars": 19832,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _categorical_tutorial:\\n\",\n    \"\\n\",\n"
  },
  {
    "path": "doc/_tutorial/color_palettes.ipynb",
    "chars": 35065,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {\n    \"raw_mimetype\": \"text/restructuredtext\"\n   },\n   \"source\":"
  },
  {
    "path": "doc/_tutorial/data_structure.ipynb",
    "chars": 19941,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _data_tutorial:\\n\",\n    \"\\n\",\n    \".."
  },
  {
    "path": "doc/_tutorial/distributions.ipynb",
    "chars": 28886,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _distribution_tutorial:\\n\",\n    \"\\n\","
  },
  {
    "path": "doc/_tutorial/error_bars.ipynb",
    "chars": 15114,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _errorbar_tutorial:\\n\",\n    \"\\n\",\n   "
  },
  {
    "path": "doc/_tutorial/function_overview.ipynb",
    "chars": 19650,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _function_tutorial:\\n\",\n    \"\\n\",\n   "
  },
  {
    "path": "doc/_tutorial/introduction.ipynb",
    "chars": 18228,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _introduction:\\n\",\n    \"\\n\",\n    \".. "
  },
  {
    "path": "doc/_tutorial/objects_interface.ipynb",
    "chars": 35238,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"id\": \"35110bb9-6889-4bd5-b9d6-5a0479131433\",\n   \"metadata\": {},\n   \"source\""
  },
  {
    "path": "doc/_tutorial/properties.ipynb",
    "chars": 34853,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"id\": \"6cb222bb-4781-48b6-9675-c0ba195b5efb\",\n   \"metadata\": {},\n   \"source\""
  },
  {
    "path": "doc/_tutorial/regression.ipynb",
    "chars": 15407,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _regression_tutorial:\\n\",\n    \"\\n\",\n "
  },
  {
    "path": "doc/_tutorial/relational.ipynb",
    "chars": 21730,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"raw\",\n   \"metadata\": {},\n   \"source\": [\n    \".. _relational_tutorial:\\n\",\n    \"\\n\",\n "
  },
  {
    "path": "doc/api.rst",
    "chars": 3965,
    "preview": ".. _api_ref:\n\nAPI reference\n=============\n\n.. currentmodule:: seaborn.objects\n\n.. _objects_api:\n\nObjects interface\n-----"
  },
  {
    "path": "doc/citing.rst",
    "chars": 1590,
    "preview": ".. _citing:\n\nCiting and logo\n===============\n\nCiting seaborn\n--------------\n\nIf seaborn is integral to a scientific publ"
  },
  {
    "path": "doc/conf.py",
    "chars": 5823,
    "preview": "# Configuration file for the Sphinx documentation builder.\n#\n# This file only contains a selection of the most common op"
  },
  {
    "path": "doc/example_thumbs/.gitkeep",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "doc/faq.rst",
    "chars": 29857,
    "preview": ".. currentmodule:: seaborn\n\nFrequently asked questions\n==========================\n\nThis is a collection of answers to qu"
  },
  {
    "path": "doc/index.rst",
    "chars": 3209,
    "preview": ":html_theme.sidebar_secondary.remove:\n\nseaborn: statistical data visualization\n=======================================\n\n"
  },
  {
    "path": "doc/installing.rst",
    "chars": 5351,
    "preview": ".. _installing:\n\n.. currentmodule:: seaborn\n\nInstalling and getting started\n------------------------------\n\nOfficial rel"
  },
  {
    "path": "doc/make.bat",
    "chars": 800,
    "preview": "@ECHO OFF\r\n\r\npushd %~dp0\r\n\r\nREM Command file for Sphinx documentation\r\n\r\nif \"%SPHINXBUILD%\" == \"\" (\r\n\tset SPHINXBUILD=sp"
  },
  {
    "path": "doc/matplotlibrc",
    "chars": 21,
    "preview": "savefig.bbox : tight\n"
  },
  {
    "path": "doc/sphinxext/gallery_generator.py",
    "chars": 10739,
    "preview": "\"\"\"\nSphinx plugin to run example scripts and create a gallery page.\n\nLightly modified from the mpld3 project.\n\n\"\"\"\nimpor"
  },
  {
    "path": "doc/sphinxext/tutorial_builder.py",
    "chars": 11271,
    "preview": "from pathlib import Path\nimport warnings\n\nfrom jinja2 import Environment\nimport yaml\n\nimport numpy as np\nimport matplotl"
  },
  {
    "path": "doc/tools/extract_examples.py",
    "chars": 1775,
    "preview": "\"\"\"Turn the examples section of a function docstring into a notebook.\"\"\"\nimport re\nimport sys\nimport pydoc\nimport seabor"
  },
  {
    "path": "doc/tools/generate_logos.py",
    "chars": 6982,
    "preview": "import numpy as np\nimport seaborn as sns\nfrom matplotlib import patches\nimport matplotlib.pyplot as plt\nfrom scipy.signa"
  },
  {
    "path": "doc/tools/nb_to_doc.py",
    "chars": 5919,
    "preview": "#! /usr/bin/env python\n\"\"\"Execute a .ipynb file, write out a processed .rst and clean .ipynb.\n\nSome functions in this sc"
  },
  {
    "path": "doc/tools/set_nb_kernels.py",
    "chars": 535,
    "preview": "\"\"\"Recursively set the kernel name for all jupyter notebook files.\"\"\"\nimport sys\nfrom glob import glob\n\nimport nbformat\n"
  },
  {
    "path": "doc/tutorial.yaml",
    "chars": 483,
    "preview": "- title:\n  pages:\n    - introduction\n- title: API Overview\n  pages:\n    - function_overview\n    - data_structure\n- title"
  },
  {
    "path": "doc/whatsnew/index.rst",
    "chars": 830,
    "preview": ".. _whatsnew:\n\nWhat's new in each version\n==========================\n\nv0.13\n-----\n.. toctree::\n   :maxdepth: 2\n\n   v0.13"
  },
  {
    "path": "doc/whatsnew/v0.10.0.rst",
    "chars": 1268,
    "preview": "\nv0.10.0 (January 2020)\n----------------------\n\nThis is a major update that is being released simultaneously with versio"
  },
  {
    "path": "doc/whatsnew/v0.10.1.rst",
    "chars": 1234,
    "preview": "\nv0.10.1 (April 2020)\n--------------------\n\nThis is minor release with bug fixes for issues identified since 0.10.0.\n\n- "
  },
  {
    "path": "doc/whatsnew/v0.11.0.rst",
    "chars": 17019,
    "preview": "\nv0.11.0 (September 2020)\n------------------------\n\nThis is a major release with several important new features, enhance"
  },
  {
    "path": "doc/whatsnew/v0.11.1.rst",
    "chars": 2269,
    "preview": "\nv0.11.1 (December 2020)\n-----------------------\n\nThis a bug fix release and is a recommended upgrade for all users on v"
  },
  {
    "path": "doc/whatsnew/v0.11.2.rst",
    "chars": 5165,
    "preview": "\nv0.11.2 (August 2021)\n---------------------\n\nThis is a minor release that addresses issues in the v0.11 series and adds"
  },
  {
    "path": "doc/whatsnew/v0.12.0.rst",
    "chars": 10659,
    "preview": "v0.12.0 (September 2022)\n------------------------\n\nIntroduction of the objects interface\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
  },
  {
    "path": "doc/whatsnew/v0.12.1.rst",
    "chars": 2265,
    "preview": "\nv0.12.1 (October 2022)\n----------------------\n\nThis is an incremental release that is a recommended upgrade for all use"
  },
  {
    "path": "doc/whatsnew/v0.12.2.rst",
    "chars": 1375,
    "preview": "\nv0.12.2 (December 2022)\n-----------------------\n\nThis is an incremental release that is a recommended upgrade for all u"
  },
  {
    "path": "doc/whatsnew/v0.13.0.rst",
    "chars": 12604,
    "preview": "v0.13.0 (September 2023)\n------------------------\n\nThis is a major release with a number of important new features and c"
  },
  {
    "path": "doc/whatsnew/v0.13.1.rst",
    "chars": 1327,
    "preview": "v0.13.1 (December 2023)\n-----------------------\n\nThis is a minor release with some bug fixes and a couple new features. "
  },
  {
    "path": "doc/whatsnew/v0.13.2.rst",
    "chars": 182,
    "preview": "v0.13.2 (January 2024)\n----------------------\n\nThis is a minor release containing internal changes that adapt to upcomin"
  },
  {
    "path": "doc/whatsnew/v0.2.0.rst",
    "chars": 5790,
    "preview": "\nv0.2.0 (December 2013)\n----------------------\n\nThis is a major release from 0.1 with a number of API changes, enhanceme"
  },
  {
    "path": "doc/whatsnew/v0.2.1.rst",
    "chars": 829,
    "preview": "\nv0.2.1 (December 2013)\n----------------------\n\nThis is a bugfix release, with no new features.\n\nBug fixes\n~~~~~~~~~\n\n- "
  },
  {
    "path": "doc/whatsnew/v0.3.0.rst",
    "chars": 6530,
    "preview": "\nv0.3.0 (March 2014)\n-------------------\n\nThis is a major release from 0.2 with a number of enhancements to the plotting"
  },
  {
    "path": "doc/whatsnew/v0.3.1.rst",
    "chars": 993,
    "preview": "\nv0.3.1 (April 2014)\n-------------------\n\nThis is a minor release from 0.3 with fixes for several bugs.\n\nPlotting functi"
  },
  {
    "path": "doc/whatsnew/v0.4.0.rst",
    "chars": 4236,
    "preview": "\nv0.4.0 (September 2014)\n-----------------------\n\nThis is a major release from 0.3. Highlights include new approaches fo"
  },
  {
    "path": "doc/whatsnew/v0.5.0.rst",
    "chars": 4663,
    "preview": "\nv0.5.0 (November 2014)\n--------------------------\n\nThis is a major release from 0.4. Highlights include new functions f"
  },
  {
    "path": "doc/whatsnew/v0.5.1.rst",
    "chars": 602,
    "preview": "\nv0.5.1 (November 2014)\n----------------------\n\nThis is a bugfix release that includes a workaround for an issue in matp"
  },
  {
    "path": "doc/whatsnew/v0.6.0.rst",
    "chars": 11154,
    "preview": "\nv0.6.0 (June 2015)\n------------------\n\nThis is a major release from 0.5. The main objective of this release was to unif"
  },
  {
    "path": "doc/whatsnew/v0.7.0.rst",
    "chars": 2811,
    "preview": "\nv0.7.0 (January 2016)\n---------------------\n\nThis is a major release from 0.6. The main new feature is :func:`swarmplot"
  },
  {
    "path": "doc/whatsnew/v0.7.1.rst",
    "chars": 1999,
    "preview": "\nv0.7.1 (June 2016)\n-------------------\n\n- Added the ability to put \"caps\" on the error bars that are drawn by :func:`ba"
  },
  {
    "path": "doc/whatsnew/v0.8.0.rst",
    "chars": 4369,
    "preview": "\nv0.8.0 (July 2017)\n------------------\n\n- The default style is no longer applied when seaborn is imported. It is now nec"
  },
  {
    "path": "doc/whatsnew/v0.8.1.rst",
    "chars": 1444,
    "preview": "\nv0.8.1 (September 2017)\n-----------------------\n\n- Added a warning in :class:`FacetGrid` when passing a categorical plo"
  },
  {
    "path": "doc/whatsnew/v0.9.0.rst",
    "chars": 10773,
    "preview": "\nv0.9.0 (July 2018)\n------------------\n\nThis is a major release with several substantial and long-desired new features. "
  },
  {
    "path": "doc/whatsnew/v0.9.1.rst",
    "chars": 4936,
    "preview": "\nv0.9.1 (January 2020)\n---------------------\n\nThis is a minor release with a number of bug fixes and adaptations to chan"
  },
  {
    "path": "examples/.gitignore",
    "chars": 16,
    "preview": "*.html\n*_files/\n"
  },
  {
    "path": "examples/anscombes_quartet.py",
    "chars": 422,
    "preview": "\"\"\"\nAnscombe's quartet\n==================\n\n_thumb: .4, .4\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style=\"ticks\")\n\n# Load"
  },
  {
    "path": "examples/different_scatter_variables.py",
    "chars": 769,
    "preview": "\"\"\"\nScatterplot with multiple semantics\n===================================\n\n_thumb: .45, .5\n\n\"\"\"\nimport seaborn as sns\n"
  },
  {
    "path": "examples/errorband_lineplots.py",
    "chars": 387,
    "preview": "\"\"\"\nTimeseries plot with error bands\n================================\n\n_thumb: .48, .45\n\n\"\"\"\nimport seaborn as sns\nsns.s"
  },
  {
    "path": "examples/faceted_histogram.py",
    "chars": 329,
    "preview": "\"\"\"\nFacetting histograms by subsets of data\n=======================================\n\n_thumb: .33, .57\n\"\"\"\nimport seaborn"
  },
  {
    "path": "examples/faceted_lineplot.py",
    "chars": 524,
    "preview": "\"\"\"\nLine plots on multiple facets\n=============================\n\n_thumb: .48, .42\n\n\"\"\"\nimport seaborn as sns\nsns.set_the"
  },
  {
    "path": "examples/grouped_barplot.py",
    "chars": 431,
    "preview": "\"\"\"\nGrouped barplots\n================\n\n_thumb: .36, .5\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style=\"whitegrid\")\n\npengu"
  },
  {
    "path": "examples/grouped_boxplot.py",
    "chars": 390,
    "preview": "\"\"\"\nGrouped boxplots\n================\n\n_thumb: .66, .45\n\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style=\"ticks\", palette="
  },
  {
    "path": "examples/grouped_violinplots.py",
    "chars": 460,
    "preview": "\"\"\"\nGrouped violinplots with split violins\n======================================\n\n_thumb: .44, .47\n\"\"\"\nimport seaborn a"
  },
  {
    "path": "examples/heat_scatter.py",
    "chars": 1118,
    "preview": "\"\"\"\nScatterplot heatmap\n-------------------\n\n_thumb: .5, .5\n\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style=\"whitegrid\")\n"
  },
  {
    "path": "examples/hexbin_marginals.py",
    "chars": 323,
    "preview": "\"\"\"\nHexbin plot with marginal distributions\n=======================================\n\n_thumb: .45, .4\n\"\"\"\nimport numpy as"
  },
  {
    "path": "examples/histogram_stacked.py",
    "chars": 562,
    "preview": "\"\"\"\nStacked histogram on a log scale\n================================\n\n_thumb: .5, .45\n\n\"\"\"\nimport seaborn as sns\nimport"
  },
  {
    "path": "examples/horizontal_boxplot.py",
    "chars": 743,
    "preview": "\"\"\"\nHorizontal boxplot with observations\n====================================\n\n_thumb: .7, .37\n\"\"\"\nimport seaborn as sns"
  },
  {
    "path": "examples/jitter_stripplot.py",
    "chars": 1059,
    "preview": "\"\"\"\nConditional means with observations\n===================================\n\n\"\"\"\nimport seaborn as sns\nimport matplotlib"
  },
  {
    "path": "examples/joint_histogram.py",
    "chars": 696,
    "preview": "\"\"\"\nJoint and marginal histograms\n=============================\n\n_thumb: .52, .505\n\n\"\"\"\nimport seaborn as sns\nsns.set_th"
  },
  {
    "path": "examples/joint_kde.py",
    "chars": 381,
    "preview": "\"\"\"\nJoint kernel density estimate\n=============================\n\n_thumb: .6, .4\n\"\"\"\nimport seaborn as sns\nsns.set_theme("
  },
  {
    "path": "examples/kde_ridgeplot.py",
    "chars": 1374,
    "preview": "\"\"\"\nOverlapping densities ('ridge plot')\n====================================\n\n\n\"\"\"\nimport numpy as np\nimport pandas as "
  },
  {
    "path": "examples/large_distributions.py",
    "chars": 355,
    "preview": "\"\"\"\nPlotting large distributions\n============================\n\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style=\"whitegrid\""
  },
  {
    "path": "examples/layered_bivariate_plot.py",
    "chars": 617,
    "preview": "\"\"\"\nBivariate plot with multiple elements\n=====================================\n\n\n\"\"\"\nimport numpy as np\nimport seaborn "
  },
  {
    "path": "examples/logistic_regression.py",
    "chars": 538,
    "preview": "\"\"\"\nFaceted logistic regression\n===========================\n\n_thumb: .58, .5\n\"\"\"\nimport seaborn as sns\nsns.set_theme(sty"
  },
  {
    "path": "examples/many_facets.py",
    "chars": 1110,
    "preview": "\"\"\"\nPlotting on a large number of facets\n====================================\n\n_thumb: .4, .3\n\n\"\"\"\nimport numpy as np\nim"
  },
  {
    "path": "examples/many_pairwise_correlations.py",
    "chars": 908,
    "preview": "\"\"\"\nPlotting a diagonal correlation matrix\n======================================\n\n_thumb: .3, .6\n\"\"\"\nfrom string import"
  },
  {
    "path": "examples/marginal_ticks.py",
    "chars": 491,
    "preview": "\"\"\"\nScatterplot with marginal ticks\n===============================\n\n_thumb: .66, .34\n\"\"\"\nimport seaborn as sns\nsns.set_"
  },
  {
    "path": "examples/multiple_bivariate_kde.py",
    "chars": 482,
    "preview": "\"\"\"\nMultiple bivariate KDE plots\n============================\n\n_thumb: .6, .45\n\"\"\"\nimport seaborn as sns\nimport matplotl"
  },
  {
    "path": "examples/multiple_conditional_kde.py",
    "chars": 452,
    "preview": "\"\"\"\nConditional kernel density estimate\n===================================\n\n_thumb: .4, .5\n\"\"\"\nimport seaborn as sns\nsn"
  },
  {
    "path": "examples/multiple_ecdf.py",
    "chars": 381,
    "preview": "\"\"\"\nFacetted ECDF plots\n===================\n\n_thumb: .30, .49\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style=\"ticks\")\nmpg"
  },
  {
    "path": "examples/multiple_regression.py",
    "chars": 481,
    "preview": "\"\"\"\nMultiple linear regression\n==========================\n\n_thumb: .45, .45\n\"\"\"\nimport seaborn as sns\nsns.set_theme()\n\n#"
  },
  {
    "path": "examples/pair_grid_with_kde.py",
    "chars": 317,
    "preview": "\"\"\"\nPaired density and scatterplot matrix\n=====================================\n\n_thumb: .5, .5\n\"\"\"\nimport seaborn as sn"
  },
  {
    "path": "examples/paired_pointplots.py",
    "chars": 537,
    "preview": "\"\"\"\nPaired categorical plots\n========================\n\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style=\"whitegrid\")\n\n# Loa"
  },
  {
    "path": "examples/pairgrid_dotplot.py",
    "chars": 1096,
    "preview": "\"\"\"\nDot plot with several variables\n===============================\n\n_thumb: .3, .3\n\"\"\"\nimport seaborn as sns\nsns.set_th"
  },
  {
    "path": "examples/palette_choices.py",
    "chars": 1013,
    "preview": "\"\"\"\nColor palette choices\n=====================\n\n\"\"\"\nimport numpy as np\nimport seaborn as sns\nimport matplotlib.pyplot a"
  },
  {
    "path": "examples/palette_generation.py",
    "chars": 891,
    "preview": "\"\"\"\nDifferent cubehelix palettes\n============================\n\n_thumb: .4, .65\n\"\"\"\nimport numpy as np\nimport seaborn as "
  },
  {
    "path": "examples/part_whole_bars.py",
    "chars": 868,
    "preview": "\"\"\"\nHorizontal bar plots\n====================\n\n\"\"\"\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nsns.set_theme(s"
  },
  {
    "path": "examples/pointplot_anova.py",
    "chars": 483,
    "preview": "\"\"\"\nPlotting a three-way ANOVA\n==========================\n\n_thumb: .42, .5\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style"
  },
  {
    "path": "examples/radial_facets.py",
    "chars": 747,
    "preview": "\"\"\"\nFacetGrid with custom projection\n================================\n\n_thumb: .33, .5\n\n\"\"\"\nimport numpy as np\nimport pa"
  },
  {
    "path": "examples/regression_marginals.py",
    "chars": 390,
    "preview": "\"\"\"\nLinear regression with marginal distributions\n=============================================\n\n_thumb: .65, .65\n\"\"\"\nim"
  },
  {
    "path": "examples/residplot.py",
    "chars": 362,
    "preview": "\"\"\"\nPlotting model residuals\n========================\n\n\"\"\"\nimport numpy as np\nimport seaborn as sns\nsns.set_theme(style="
  },
  {
    "path": "examples/scatter_bubbles.py",
    "chars": 451,
    "preview": "\"\"\"\nScatterplot with varying point sizes and hues\n==============================================\n\n_thumb: .45, .5\n\n\"\"\"\ni"
  },
  {
    "path": "examples/scatterplot_categorical.py",
    "chars": 386,
    "preview": "\"\"\"\nScatterplot with categorical variables\n======================================\n\n_thumb: .45, .45\n\n\"\"\"\nimport seaborn "
  },
  {
    "path": "examples/scatterplot_matrix.py",
    "chars": 180,
    "preview": "\"\"\"\nScatterplot Matrix\n==================\n\n_thumb: .3, .2\n\"\"\"\nimport seaborn as sns\nsns.set_theme(style=\"ticks\")\n\ndf = s"
  }
]

// ... and 110 more files (download for full content)