from enum import Enum

class _AutoStringNameEnum(Enum):

def __hash__(self): ...

class JoinStyle(str, _AutoStringNameEnum):

miter: str

round: str

bevel: str

@staticmethod

def demo() -> None: ...

class CapStyle(str, _AutoStringNameEnum):

butt: str

projecting: str

round: str

@staticmethod

def demo() -> None: ...

_GlueSpec._named = { # type: ignore[attr-defined]

from typing import Sequence

import numpy as np

from .transforms import BboxBase

def affine_transform(points: np.ndarray, matrix: np.ndarray) -> np.ndarray: ...

def count_bboxes_overlapping_bbox(a: BboxBase, bboxes: Sequence[BboxBase]) -> int: ...

def update_path_extents(*args, **kwargs): ...

from collections import OrderedDict

from matplotlib.backend_bases import FigureManagerBase

from matplotlib.figure import Figure

class Gcf:

figs: OrderedDict[int, FigureManagerBase]

@classmethod

def get_fig_manager(cls, num: int) -> FigureManagerBase: ...

@classmethod

def destroy(cls, num: int | FigureManagerBase) -> None: ...

@classmethod

def destroy_fig(cls, fig: Figure) -> None: ...

@classmethod

def destroy_all(cls) -> None: ...

@classmethod

def has_fignum(cls, num: int) -> bool: ...

@classmethod

def get_all_fig_managers(cls) -> list[FigureManagerBase]: ...

@classmethod

def get_num_fig_managers(cls) -> int: ...

@classmethod

def get_active(cls) -> FigureManagerBase: ...

@classmethod

def set_active(cls, manager: FigureManagerBase) -> None: ...

@classmethod

def draw_all(cls, force: bool = ...) -> None: ...

from typing import Any

class TrapezoidMapTriFinder:

def __init__(self, *args, **kwargs) -> None: ...

def find_many(self, *args, **kwargs) -> Any: ...

def get_tree_stats(self, *args, **kwargs) -> Any: ...

def initialize(self, *args, **kwargs) -> Any: ...

def print_tree(self, *args, **kwargs) -> Any: ...

class TriContourGenerator:

def __init__(self, *args, **kwargs) -> None: ...

def create_contour(self, *args, **kwargs) -> Any: ...

def create_filled_contour(self, *args, **kwargs) -> Any: ...

class Triangulation:

def __init__(self, *args, **kwargs) -> None: ...

def calculate_plane_coefficients(self, *args, **kwargs) -> Any: ...

def get_edges(self, *args, **kwargs) -> Any: ...

def get_neighbors(self, *args, **kwargs) -> Any: ...

def set_mask(self, *args, **kwargs) -> Any: ...

import abc

from collections.abc import Generator

import contextlib

from pathlib import Path

from matplotlib import cbook

from matplotlib._animation_data import DISPLAY_TEMPLATE, INCLUDED_FRAMES, JS_INCLUDE, STYLE_INCLUDE

from matplotlib.artist import Artist

from matplotlib.backend_bases import TimerBase

from matplotlib.figure import Figure

from typing import Any, Callable, Iterable, Generator, Type

subprocess_creation_flags: int

def adjusted_figsize(w: float, h: float, dpi: float, n: int) -> tuple[float, float]: ...

class MovieWriterRegistry:

def __init__(self) -> None: ...

def register(self, name: str) -> Callable[[Type[AbstractMovieWriter]], Type[AbstractMovieWriter]]: ...

def is_available(self, name: str) -> bool: ...

def __iter__(self) -> Generator[str, None, None]: ...

def list(self) -> list[str]: ...

def __getitem__(self, name: str) -> Type[AbstractMovieWriter]: ...

writers: MovieWriterRegistry

class AbstractMovieWriter(abc.ABC, metaclass=abc.ABCMeta):

fps: int

metadata: dict[str, str]

codec: str

bitrate: int

def __init__(self, fps: int = ..., metadata: dict[str, str] | None = ..., codec: str | None = ..., bitrate: int | None = ...) -> None: ...

outfile: str | Path

fig: Figure

dpi: float

@abc.abstractmethod

def setup(self, fig: Figure, outfile: str | Path, dpi: float | None = ...): ...

@property

def frame_size(self) -> tuple[int, int]: ...

@abc.abstractmethod

def grab_frame(self, **savefig_kwargs) -> None: ...

@abc.abstractmethod

def finish(self) -> None: ...

@contextlib.contextmanager

def saving(self, fig: Figure, outfile: str | Path, dpi: float | None, *args, **kwargs) -> Generator[AbstractMovieWriter, None, None]: ...

class MovieWriter(AbstractMovieWriter):

supported_formats: list[str]

frame_format: str

extra_args: list[str] | None

def __init__(self, fps: int = ..., codec: str | None = ..., bitrate: int | None = ..., extra_args: list[str] | None = ..., metadata: dict[str, str] | None = ...) -> None: ...

def setup(self, fig: Figure, outfile: str | Path, dpi: float | None = ...): ...

def grab_frame(self, **savefig_kwargs) -> None: ...

def finish(self) -> None: ...

@classmethod

def bin_path(cls) -> str: ...

@classmethod

def isAvailable(cls) -> bool: ...

class FileMovieWriter(MovieWriter):

fig: Figure

outfile: str | Path

dpi: float

temp_prefix: str

fname_format_str: str

def setup(self, fig: Figure, outfile: str | Path, dpi: float | None = ..., frame_prefix: str | Path | None = ...) -> None: ...

def __del__(self) -> None: ...

@property

def frame_format(self) -> str: ...

@frame_format.setter

def frame_format(self, frame_format: str) -> None: ...

class PillowWriter(AbstractMovieWriter):

@classmethod

def isAvailable(cls) -> bool: ...

def setup(self, fig: Figure, outfile: str | Path, dpi: float | None = ...) -> None: ...

def grab_frame(self, **savefig_kwargs) -> None: ...

def finish(self) -> None: ...

class FFMpegBase:

codec: str

@property

def output_args(self) -> list[str]: ...

class FFMpegWriter(FFMpegBase, MovieWriter): ...

class FFMpegFileWriter(FFMpegBase, FileMovieWriter):

supported_formats: list[str]

class ImageMagickBase:

@classmethod

def bin_path(cls) -> str: ...

@classmethod

def isAvailable(cls) -> bool: ...

class ImageMagickWriter(ImageMagickBase, MovieWriter):

input_names: str

class ImageMagickFileWriter(ImageMagickBase, FileMovieWriter):

supported_formats: list[str]

@property

def input_names(self) -> str: ...

class HTMLWriter(FileMovieWriter):

supported_formats: list[str]

@classmethod

def isAvailable(cls) -> bool: ...

embed_frames: bool

default_mode: str

def __init__(self, fps: int = ..., codec: str | None = ..., bitrate: int | None = ..., extra_args: list[str] | None = ..., metadata: dict[str, str] | None = ..., embed_frames: bool = ..., default_mode: str = ..., embed_limit: float | None = ...) -> None: ...

def setup(self, fig: Figure, outfile: str | Path, dpi: float | None = ..., frame_dir: str | Path | None = ...) -> None: ...

def grab_frame(self, **savefig_kwargs): ...

def finish(self) -> None: ...

class Animation:

frame_seq: Iterable[Artist]

event_source: Any

def __init__(self, fig: Figure, event_source: Any | None = ..., blit: bool = ...) -> None: ...

def __del__(self) -> None: ...

def save(self, filename: str | Path, writer: MovieWriter | str | None = ..., fps: int | None = ..., dpi: float | None = ..., codec: str | None = ..., bitrate: int | None = ..., extra_args: list[str] | None = ..., metadata: dict[str, str] | None = ..., extra_anim: list[Animation] | None = ..., savefig_kwargs: dict[str, Any] | None = ..., *, progress_callback: Callable[[int, int], Any] | None = ...) -> None: ...

def new_frame_seq(self) -> Iterable[Artist]: ...

def new_saved_frame_seq(self) -> Iterable[Artist]: ...

def to_html5_video(self, embed_limit: float | None = ...) -> str: ...

def to_jshtml(self, fps: int | None = ..., embed_frames: bool = ..., default_mode: str | None = ...) -> str: ...

def pause(self) -> None: ...

def resume(self) -> None: ...

class TimedAnimation(Animation):

repeat: bool

def __init__(self, fig: Figure, interval: int = ..., repeat_delay: int = ..., repeat: bool = ..., event_source: TimerBase | None = ..., *args, **kwargs) -> None: ...

class ArtistAnimation(TimedAnimation):

def __init__(self, fig: Figure, artists: list[Artist], *args, **kwargs) -> None: ...

class FuncAnimation(TimedAnimation):

save_count: int

def __init__(self, fig: Figure, func: Callable[..., Iterable[Artist]], frames: Iterable[Artist] | int | Generator[Artist, None, None] | None = ..., init_func: Callable[[], Iterable[Artist]] | None = ..., fargs: tuple[Any, ...] | None = ..., save_count: int | None = ..., *, cache_frame_data: bool = ..., **kwargs) -> None: ...

from . import cbook as cbook

from .axes import Axes

from .axes._base import _AxesBase

from .backend_bases import RendererBase, MouseEvent

from .cm import ScalarMappable

from .colors import BoundaryNorm

from .figure import Figure, FigureBase

from .path import Path

from .patches import Patch

from .patheffects import AbstractPathEffect

from .transforms import Bbox, IdentityTransform, Transform, TransformedBbox, TransformedPatchPath, TransformedPath

import numpy as np

from typing import Any, NamedTuple, Callable, TextIO, Type, TypeVar, overload

from numpy.typing import ArrayLike

def allow_rasterization(draw): ...

class _XYPair(NamedTuple):

x: ArrayLike

y: ArrayLike

class _Unset: ...

class Artist:

zorder: float

def __init_subclass__(cls): ...

stale_callback: Callable[[Artist, bool], None] | None

figure: FigureBase | None

clipbox: Bbox | None

def __init__(self) -> None: ...

def remove(self) -> None: ...

def have_units(self) -> bool: ...

# TODO units

def convert_xunits(self, x): ...

def convert_yunits(self, y): ...

@property

def axes(self) -> _AxesBase | None: ...

@axes.setter

def axes(self, new_axes: _AxesBase | None) -> None: ...

@property

def stale(self) -> bool: ...

@stale.setter

def stale(self, val: bool) -> None: ...

def get_window_extent(self, renderer: RendererBase | None = ...) -> Bbox: ...

def get_tightbbox(self, renderer: RendererBase | None = ...) -> Bbox | None: ...

def add_callback(self, func: Callable[[Artist], Any]) -> int: ...

def remove_callback(self, oid: int) -> None: ...

def pchanged(self) -> None: ...

def is_transform_set(self) -> bool: ...

def set_transform(self, t: Transform) -> None: ...

def get_transform(self) -> Transform: ...

def get_children(self) -> list[Artist]: ...

# TODO can these dicts be type narrowed? e.g. str keys

def contains(self, mouseevent: MouseEvent) -> tuple[bool, dict[Any, Any]]: ...

def pickable(self) -> bool: ...

def pick(self, mouseevent: MouseEvent) -> None: ...

def set_picker(self, picker: None | bool | float | Callable[[Artist, MouseEvent], tuple[bool, dict[Any, Any]]]) -> None: ...

def get_picker(self) -> None | bool | float | Callable[[Artist, MouseEvent], tuple[bool, dict[Any, Any]]]: ...

def get_url(self) -> str | None: ...

def set_url(self, url: str | None) -> None: ...

def get_gid(self) -> str | None: ...

def set_gid(self, gid: str | None) -> None: ...

def get_snap(self) -> bool | None: ...

def set_snap(self, snap: bool | None) -> None: ...

def get_sketch_params(self) -> tuple[float, float, float] | None: ...

def set_sketch_params(self, scale: float | None = ..., length: float | None = ..., randomness: float | None = ...) -> None: ...

def set_path_effects(self, path_effects: AbstractPathEffect) -> None: ...

def get_path_effects(self) -> AbstractPathEffect: ...

def get_figure(self) -> Figure | None: ...

def set_figure(self, fig: Figure) -> None: ...

def set_clip_box(self, clipbox: Bbox) -> None: ...

def set_clip_path(self, path: Patch | Path | TransformedPath | TransformedPatchPath | None, transform: Transform | None = ...) -> None: ...

def get_alpha(self) -> float | None: ...

def get_visible(self) -> bool: ...

def get_animated(self) -> bool: ...

def get_in_layout(self) -> bool: ...

def get_clip_on(self) -> bool: ...

def get_clip_box(self) -> Bbox | None: ...

def get_clip_path(self) -> Patch | Path | TransformedPath | TransformedPatchPath | None: ...

def get_transformed_clip_path_and_affine(self) -> tuple[None, None] | tuple[Path, Transform]: ...

def set_clip_on(self, b: bool) -> None: ...

def get_rasterized(self) -> bool: ...

def set_rasterized(self, rasterized: bool) -> None: ...

def get_agg_filter(self): ...

def set_agg_filter(self, filter_func: Callable[[ArrayLike, float], tuple[np.ndarray, float, float]]) -> None: ...

def draw(self, renderer: RendererBase) -> None: ...

def set_alpha(self, alpha: float | None) -> None: ...

def set_visible(self, b: bool) -> None: ...

def set_animated(self, b: bool) -> None: ...

def set_in_layout(self, in_layout: bool) -> None: ...

def get_label(self) -> object: ...

def set_label(self, s: object) -> None: ...

def get_zorder(self) -> float: ...

def set_zorder(self, level: float) -> None: ...

@property

def sticky_edges(self) -> ArrayLike: ...

def update_from(self, other: Artist) -> None: ...

def properties(self) -> dict[str, Any]: ...

def update(self, props: dict[str, Any]) -> Any: ...

def _internal_update(self, kwargs): ...

def set(self, **kwargs: Any): ...

def findobj(self, match: None | Callable[[Artist], bool] | Type[Artist] = ..., include_self: bool = ...) -> list[Artist]: ...

def get_cursor_data(self, event: MouseEvent) -> Any: ...

def format_cursor_data(self, data: Any) -> str: ...

def get_mouseover(self) -> bool: ...

def set_mouseover(self, mouseover: bool) -> None: ...

class ArtistInspector:

oorig: Artist | Type[Artist]

o: Type[Artist]

aliasd: dict[str, set[str]]

def __init__(self, o) -> None: ...

def get_aliases(self) -> dict[str, set[str]]: ...

def get_valid_values(self, attr: str) -> str | None: ...

def get_setters(self) -> list[str]: ...

@staticmethod

def number_of_parameters(func: Callable) -> int: ...

@staticmethod

def is_alias(method: Callable) -> bool: ...

def aliased_name(self, s: str) -> str: ...

def aliased_name_rest(self, s: str, target: str) -> str: ...

@overload

def pprint_setters(self, prop: None = ..., leadingspace: int = ...) -> list[str]: ...

@overload

def pprint_setters(self, prop: str, leadingspace: int = ...) -> str: ...

@overload

def pprint_setters_rest(self, prop: None = ..., leadingspace: int = ...) -> list[str]: ...

@overload

def pprint_setters_rest(self, prop: str, leadingspace: int = ...) -> str: ...

def properties(self) -> dict[str, Any]: ...

def pprint_getters(self) -> list[str]: ...

def getp(obj: Artist, property: str | None = ...) -> Any: ...

get = getp

def setp(obj: Artist, *args, file: TextIO | None = ..., **kwargs): ...

def kwdoc(artist: Artist) -> str: ...

from ._axes import *

from ._axes import Axes as Subplot

class _SubplotBaseMeta(type):

def __instancecheck__(self, obj) -> bool: ...

class SubplotBase(metaclass=_SubplotBaseMeta): ...

def subplot_class_factory(cls): ...