| from . import artist |
| from .axes import Axes |
| from .backend_bases import RendererBase, MouseEvent |
| from .path import Path |
| from .transforms import Transform, Bbox |
|
|
| from typing import Any, Literal, overload |
|
|
| import numpy as np |
| from numpy.typing import ArrayLike |
| from .typing import ColorType, LineStyleType, CapStyleType, JoinStyleType |
|
|
| class Patch(artist.Artist): |
| zorder: float |
| def __init__( |
| self, |
| *, |
| edgecolor: ColorType | None = ..., |
| facecolor: ColorType | None = ..., |
| color: ColorType | None = ..., |
| linewidth: float | None = ..., |
| linestyle: LineStyleType | None = ..., |
| antialiased: bool | None = ..., |
| hatch: str | None = ..., |
| fill: bool = ..., |
| capstyle: CapStyleType | None = ..., |
| joinstyle: JoinStyleType | None = ..., |
| **kwargs, |
| ) -> None: ... |
| def get_verts(self) -> ArrayLike: ... |
| def contains(self, mouseevent: MouseEvent, radius: float | None = None) -> tuple[bool, dict[Any, Any]]: ... |
| def contains_point( |
| self, point: tuple[float, float], radius: float | None = ... |
| ) -> bool: ... |
| def contains_points( |
| self, points: ArrayLike, radius: float | None = ... |
| ) -> np.ndarray: ... |
| def get_extents(self) -> Bbox: ... |
| def get_transform(self) -> Transform: ... |
| def get_data_transform(self) -> Transform: ... |
| def get_patch_transform(self) -> Transform: ... |
| def get_antialiased(self) -> bool: ... |
| def get_edgecolor(self) -> ColorType: ... |
| def get_facecolor(self) -> ColorType: ... |
| def get_linewidth(self) -> float: ... |
| def get_linestyle(self) -> LineStyleType: ... |
| def set_antialiased(self, aa: bool | None) -> None: ... |
| def set_edgecolor(self, color: ColorType | None) -> None: ... |
| def set_facecolor(self, color: ColorType | None) -> None: ... |
| def set_color(self, c: ColorType | None) -> None: ... |
| def set_alpha(self, alpha: float | None) -> None: ... |
| def set_linewidth(self, w: float | None) -> None: ... |
| def set_linestyle(self, ls: LineStyleType | None) -> None: ... |
| def set_fill(self, b: bool) -> None: ... |
| def get_fill(self) -> bool: ... |
| fill = property(get_fill, set_fill) |
| def set_capstyle(self, s: CapStyleType) -> None: ... |
| def get_capstyle(self) -> Literal["butt", "projecting", "round"]: ... |
| def set_joinstyle(self, s: JoinStyleType) -> None: ... |
| def get_joinstyle(self) -> Literal["miter", "round", "bevel"]: ... |
| def set_hatch(self, hatch: str) -> None: ... |
| def get_hatch(self) -> str: ... |
| def get_path(self) -> Path: ... |
|
|
| class Shadow(Patch): |
| patch: Patch |
| def __init__(self, patch: Patch, ox: float, oy: float, *, shade: float = ..., **kwargs) -> None: ... |
|
|
| class Rectangle(Patch): |
| angle: float |
| def __init__( |
| self, |
| xy: tuple[float, float], |
| width: float, |
| height: float, |
| *, |
| angle: float = ..., |
| rotation_point: Literal["xy", "center"] | tuple[float, float] = ..., |
| **kwargs, |
| ) -> None: ... |
| @property |
| def rotation_point(self) -> Literal["xy", "center"] | tuple[float, float]: ... |
| @rotation_point.setter |
| def rotation_point( |
| self, value: Literal["xy", "center"] | tuple[float, float] |
| ) -> None: ... |
| def get_x(self) -> float: ... |
| def get_y(self) -> float: ... |
| def get_xy(self) -> tuple[float, float]: ... |
| def get_corners(self) -> np.ndarray: ... |
| def get_center(self) -> np.ndarray: ... |
| def get_width(self) -> float: ... |
| def get_height(self) -> float: ... |
| def get_angle(self) -> float: ... |
| def set_x(self, x: float) -> None: ... |
| def set_y(self, y: float) -> None: ... |
| def set_angle(self, angle: float) -> None: ... |
| def set_xy(self, xy: tuple[float, float]) -> None: ... |
| def set_width(self, w: float) -> None: ... |
| def set_height(self, h: float) -> None: ... |
| @overload |
| def set_bounds(self, args: tuple[float, float, float, float], /) -> None: ... |
| @overload |
| def set_bounds( |
| self, left: float, bottom: float, width: float, height: float, / |
| ) -> None: ... |
| def get_bbox(self) -> Bbox: ... |
| xy = property(get_xy, set_xy) |
|
|
| class RegularPolygon(Patch): |
| xy: tuple[float, float] |
| numvertices: int |
| orientation: float |
| radius: float |
| def __init__( |
| self, |
| xy: tuple[float, float], |
| numVertices: int, |
| *, |
| radius: float = ..., |
| orientation: float = ..., |
| **kwargs, |
| ) -> None: ... |
|
|
| class PathPatch(Patch): |
| def __init__(self, path: Path, **kwargs) -> None: ... |
| def set_path(self, path: Path) -> None: ... |
|
|
| class StepPatch(PathPatch): |
| orientation: Literal["vertical", "horizontal"] |
| def __init__( |
| self, |
| values: ArrayLike, |
| edges: ArrayLike, |
| *, |
| orientation: Literal["vertical", "horizontal"] = ..., |
| baseline: float = ..., |
| **kwargs, |
| ) -> None: ... |
|
|
| |
| def get_data(self) -> tuple[np.ndarray, np.ndarray, float]: ... |
| def set_data( |
| self, |
| values: ArrayLike | None = ..., |
| edges: ArrayLike | None = ..., |
| baseline: float | None = ..., |
| ) -> None: ... |
|
|
| class Polygon(Patch): |
| def __init__(self, xy: ArrayLike, *, closed: bool = ..., **kwargs) -> None: ... |
| def get_closed(self) -> bool: ... |
| def set_closed(self, closed: bool) -> None: ... |
| def get_xy(self) -> np.ndarray: ... |
| def set_xy(self, xy: ArrayLike) -> None: ... |
| xy = property(get_xy, set_xy) |
|
|
| class Wedge(Patch): |
| center: tuple[float, float] |
| r: float |
| theta1: float |
| theta2: float |
| width: float | None |
| def __init__( |
| self, |
| center: tuple[float, float], |
| r: float, |
| theta1: float, |
| theta2: float, |
| *, |
| width: float | None = ..., |
| **kwargs, |
| ) -> None: ... |
| def set_center(self, center: tuple[float, float]) -> None: ... |
| def set_radius(self, radius: float) -> None: ... |
| def set_theta1(self, theta1: float) -> None: ... |
| def set_theta2(self, theta2: float) -> None: ... |
| def set_width(self, width: float | None) -> None: ... |
|
|
| class Arrow(Patch): |
| def __init__( |
| self, x: float, y: float, dx: float, dy: float, *, width: float = ..., **kwargs |
| ) -> None: ... |
| def set_data( |
| self, |
| x: float | None = ..., |
| y: float | None = ..., |
| dx: float | None = ..., |
| dy: float | None = ..., |
| width: float | None = ..., |
| ) -> None: ... |
| class FancyArrow(Polygon): |
| def __init__( |
| self, |
| x: float, |
| y: float, |
| dx: float, |
| dy: float, |
| *, |
| width: float = ..., |
| length_includes_head: bool = ..., |
| head_width: float | None = ..., |
| head_length: float | None = ..., |
| shape: Literal["full", "left", "right"] = ..., |
| overhang: float = ..., |
| head_starts_at_zero: bool = ..., |
| **kwargs, |
| ) -> None: ... |
| def set_data( |
| self, |
| *, |
| x: float | None = ..., |
| y: float | None = ..., |
| dx: float | None = ..., |
| dy: float | None = ..., |
| width: float | None = ..., |
| head_width: float | None = ..., |
| head_length: float | None = ..., |
| ) -> None: ... |
|
|
| class CirclePolygon(RegularPolygon): |
| def __init__( |
| self, |
| xy: tuple[float, float], |
| radius: float = ..., |
| *, |
| resolution: int = ..., |
| **kwargs, |
| ) -> None: ... |
|
|
| class Ellipse(Patch): |
| def __init__( |
| self, |
| xy: tuple[float, float], |
| width: float, |
| height: float, |
| *, |
| angle: float = ..., |
| **kwargs, |
| ) -> None: ... |
| def set_center(self, xy: tuple[float, float]) -> None: ... |
| def get_center(self) -> float: ... |
| center = property(get_center, set_center) |
|
|
| def set_width(self, width: float) -> None: ... |
| def get_width(self) -> float: ... |
| width = property(get_width, set_width) |
|
|
| def set_height(self, height: float) -> None: ... |
| def get_height(self) -> float: ... |
| height = property(get_height, set_height) |
|
|
| def set_angle(self, angle: float) -> None: ... |
| def get_angle(self) -> float: ... |
| angle = property(get_angle, set_angle) |
|
|
| def get_corners(self) -> np.ndarray: ... |
|
|
| def get_vertices(self) -> list[tuple[float, float]]: ... |
| def get_co_vertices(self) -> list[tuple[float, float]]: ... |
|
|
|
|
| class Annulus(Patch): |
| a: float |
| b: float |
| def __init__( |
| self, |
| xy: tuple[float, float], |
| r: float | tuple[float, float], |
| width: float, |
| angle: float = ..., |
| **kwargs, |
| ) -> None: ... |
| def set_center(self, xy: tuple[float, float]) -> None: ... |
| def get_center(self) -> tuple[float, float]: ... |
| center = property(get_center, set_center) |
|
|
| def set_width(self, width: float) -> None: ... |
| def get_width(self) -> float: ... |
| width = property(get_width, set_width) |
|
|
| def set_angle(self, angle: float) -> None: ... |
| def get_angle(self) -> float: ... |
| angle = property(get_angle, set_angle) |
|
|
| def set_semimajor(self, a: float) -> None: ... |
| def set_semiminor(self, b: float) -> None: ... |
| def set_radii(self, r: float | tuple[float, float]) -> None: ... |
| def get_radii(self) -> tuple[float, float]: ... |
| radii = property(get_radii, set_radii) |
|
|
| class Circle(Ellipse): |
| def __init__( |
| self, xy: tuple[float, float], radius: float = ..., **kwargs |
| ) -> None: ... |
| def set_radius(self, radius: float) -> None: ... |
| def get_radius(self) -> float: ... |
| radius = property(get_radius, set_radius) |
|
|
| class Arc(Ellipse): |
| theta1: float |
| theta2: float |
| def __init__( |
| self, |
| xy: tuple[float, float], |
| width: float, |
| height: float, |
| *, |
| angle: float = ..., |
| theta1: float = ..., |
| theta2: float = ..., |
| **kwargs, |
| ) -> None: ... |
|
|
| def bbox_artist( |
| artist: artist.Artist, |
| renderer: RendererBase, |
| props: dict[str, Any] | None = ..., |
| fill: bool = ..., |
| ) -> None: ... |
| def draw_bbox( |
| bbox: Bbox, |
| renderer: RendererBase, |
| color: ColorType = ..., |
| trans: Transform | None = ..., |
| ) -> None: ... |
|
|
| class _Style: |
| def __new__(cls, stylename, **kwargs): ... |
| @classmethod |
| def get_styles(cls) -> dict[str, type]: ... |
| @classmethod |
| def pprint_styles(cls) -> str: ... |
| @classmethod |
| def register(cls, name: str, style: type) -> None: ... |
|
|
| class BoxStyle(_Style): |
| class Square(BoxStyle): |
| pad: float |
| def __init__(self, pad: float = ...) -> None: ... |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class Circle(BoxStyle): |
| pad: float |
| def __init__(self, pad: float = ...) -> None: ... |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class Ellipse(BoxStyle): |
| pad: float |
| def __init__(self, pad: float = ...) -> None: ... |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class LArrow(BoxStyle): |
| pad: float |
| def __init__(self, pad: float = ...) -> None: ... |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class RArrow(LArrow): |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class DArrow(BoxStyle): |
| pad: float |
| def __init__(self, pad: float = ...) -> None: ... |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class Round(BoxStyle): |
| pad: float |
| rounding_size: float | None |
| def __init__( |
| self, pad: float = ..., rounding_size: float | None = ... |
| ) -> None: ... |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class Round4(BoxStyle): |
| pad: float |
| rounding_size: float | None |
| def __init__( |
| self, pad: float = ..., rounding_size: float | None = ... |
| ) -> None: ... |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class Sawtooth(BoxStyle): |
| pad: float |
| tooth_size: float | None |
| def __init__( |
| self, pad: float = ..., tooth_size: float | None = ... |
| ) -> None: ... |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class Roundtooth(Sawtooth): |
| def __call__( |
| self, |
| x0: float, |
| y0: float, |
| width: float, |
| height: float, |
| mutation_size: float, |
| ) -> Path: ... |
|
|
| class ConnectionStyle(_Style): |
| class _Base(ConnectionStyle): |
| def __call__( |
| self, |
| posA: tuple[float, float], |
| posB: tuple[float, float], |
| shrinkA: float = ..., |
| shrinkB: float = ..., |
| patchA: Patch | None = ..., |
| patchB: Patch | None = ..., |
| ) -> Path: ... |
|
|
| class Arc3(_Base): |
| rad: float |
| def __init__(self, rad: float = ...) -> None: ... |
| def connect( |
| self, posA: tuple[float, float], posB: tuple[float, float] |
| ) -> Path: ... |
|
|
| class Angle3(_Base): |
| angleA: float |
| angleB: float |
| def __init__(self, angleA: float = ..., angleB: float = ...) -> None: ... |
| def connect( |
| self, posA: tuple[float, float], posB: tuple[float, float] |
| ) -> Path: ... |
|
|
| class Angle(_Base): |
| angleA: float |
| angleB: float |
| rad: float |
| def __init__( |
| self, angleA: float = ..., angleB: float = ..., rad: float = ... |
| ) -> None: ... |
| def connect( |
| self, posA: tuple[float, float], posB: tuple[float, float] |
| ) -> Path: ... |
|
|
| class Arc(_Base): |
| angleA: float |
| angleB: float |
| armA: float | None |
| armB: float | None |
| rad: float |
| def __init__( |
| self, |
| angleA: float = ..., |
| angleB: float = ..., |
| armA: float | None = ..., |
| armB: float | None = ..., |
| rad: float = ..., |
| ) -> None: ... |
| def connect( |
| self, posA: tuple[float, float], posB: tuple[float, float] |
| ) -> Path: ... |
|
|
| class Bar(_Base): |
| armA: float |
| armB: float |
| fraction: float |
| angle: float | None |
| def __init__( |
| self, |
| armA: float = ..., |
| armB: float = ..., |
| fraction: float = ..., |
| angle: float | None = ..., |
| ) -> None: ... |
| def connect( |
| self, posA: tuple[float, float], posB: tuple[float, float] |
| ) -> Path: ... |
|
|
| class ArrowStyle(_Style): |
| class _Base(ArrowStyle): |
| @staticmethod |
| def ensure_quadratic_bezier(path: Path) -> list[float]: ... |
| def transmute( |
| self, path: Path, mutation_size: float, linewidth: float |
| ) -> tuple[Path, bool]: ... |
| def __call__( |
| self, |
| path: Path, |
| mutation_size: float, |
| linewidth: float, |
| aspect_ratio: float = ..., |
| ) -> tuple[Path, bool]: ... |
|
|
| class _Curve(_Base): |
| arrow: str |
| fillbegin: bool |
| fillend: bool |
| def __init__( |
| self, |
| head_length: float = ..., |
| head_width: float = ..., |
| widthA: float = ..., |
| widthB: float = ..., |
| lengthA: float = ..., |
| lengthB: float = ..., |
| angleA: float | None = ..., |
| angleB: float | None = ..., |
| scaleA: float | None = ..., |
| scaleB: float | None = ..., |
| ) -> None: ... |
|
|
| class Curve(_Curve): |
| def __init__(self) -> None: ... |
|
|
| class CurveA(_Curve): |
| arrow: str |
|
|
| class CurveB(_Curve): |
| arrow: str |
|
|
| class CurveAB(_Curve): |
| arrow: str |
|
|
| class CurveFilledA(_Curve): |
| arrow: str |
|
|
| class CurveFilledB(_Curve): |
| arrow: str |
|
|
| class CurveFilledAB(_Curve): |
| arrow: str |
|
|
| class BracketA(_Curve): |
| arrow: str |
| def __init__( |
| self, widthA: float = ..., lengthA: float = ..., angleA: float = ... |
| ) -> None: ... |
|
|
| class BracketB(_Curve): |
| arrow: str |
| def __init__( |
| self, widthB: float = ..., lengthB: float = ..., angleB: float = ... |
| ) -> None: ... |
|
|
| class BracketAB(_Curve): |
| arrow: str |
| def __init__( |
| self, |
| widthA: float = ..., |
| lengthA: float = ..., |
| angleA: float = ..., |
| widthB: float = ..., |
| lengthB: float = ..., |
| angleB: float = ..., |
| ) -> None: ... |
|
|
| class BarAB(_Curve): |
| arrow: str |
| def __init__( |
| self, |
| widthA: float = ..., |
| angleA: float = ..., |
| widthB: float = ..., |
| angleB: float = ..., |
| ) -> None: ... |
|
|
| class BracketCurve(_Curve): |
| arrow: str |
| def __init__( |
| self, widthA: float = ..., lengthA: float = ..., angleA: float | None = ... |
| ) -> None: ... |
|
|
| class CurveBracket(_Curve): |
| arrow: str |
| def __init__( |
| self, widthB: float = ..., lengthB: float = ..., angleB: float | None = ... |
| ) -> None: ... |
|
|
| class Simple(_Base): |
| def __init__( |
| self, |
| head_length: float = ..., |
| head_width: float = ..., |
| tail_width: float = ..., |
| ) -> None: ... |
|
|
| class Fancy(_Base): |
| def __init__( |
| self, |
| head_length: float = ..., |
| head_width: float = ..., |
| tail_width: float = ..., |
| ) -> None: ... |
|
|
| class Wedge(_Base): |
| tail_width: float |
| shrink_factor: float |
| def __init__( |
| self, tail_width: float = ..., shrink_factor: float = ... |
| ) -> None: ... |
|
|
| class FancyBboxPatch(Patch): |
| def __init__( |
| self, |
| xy: tuple[float, float], |
| width: float, |
| height: float, |
| boxstyle: str | BoxStyle = ..., |
| *, |
| mutation_scale: float = ..., |
| mutation_aspect: float = ..., |
| **kwargs, |
| ) -> None: ... |
| def set_boxstyle(self, boxstyle: str | BoxStyle | None = ..., **kwargs) -> None: ... |
| def get_boxstyle(self) -> BoxStyle: ... |
| def set_mutation_scale(self, scale: float) -> None: ... |
| def get_mutation_scale(self) -> float: ... |
| def set_mutation_aspect(self, aspect: float) -> None: ... |
| def get_mutation_aspect(self) -> float: ... |
| def get_x(self) -> float: ... |
| def get_y(self) -> float: ... |
| def get_width(self) -> float: ... |
| def get_height(self) -> float: ... |
| def set_x(self, x: float) -> None: ... |
| def set_y(self, y: float) -> None: ... |
| def set_width(self, w: float) -> None: ... |
| def set_height(self, h: float) -> None: ... |
| @overload |
| def set_bounds(self, args: tuple[float, float, float, float], /) -> None: ... |
| @overload |
| def set_bounds( |
| self, left: float, bottom: float, width: float, height: float, / |
| ) -> None: ... |
| def get_bbox(self) -> Bbox: ... |
|
|
| class FancyArrowPatch(Patch): |
| patchA: Patch |
| patchB: Patch |
| shrinkA: float |
| shrinkB: float |
| def __init__( |
| self, |
| posA: tuple[float, float] | None = ..., |
| posB: tuple[float, float] | None = ..., |
| *, |
| path: Path | None = ..., |
| arrowstyle: str | ArrowStyle = ..., |
| connectionstyle: str | ConnectionStyle = ..., |
| patchA: Patch | None = ..., |
| patchB: Patch | None = ..., |
| shrinkA: float = ..., |
| shrinkB: float = ..., |
| mutation_scale: float = ..., |
| mutation_aspect: float | None = ..., |
| **kwargs, |
| ) -> None: ... |
| def set_positions( |
| self, posA: tuple[float, float], posB: tuple[float, float] |
| ) -> None: ... |
| def set_patchA(self, patchA: Patch) -> None: ... |
| def set_patchB(self, patchB: Patch) -> None: ... |
| def set_connectionstyle(self, connectionstyle: str | ConnectionStyle | None = ..., **kwargs) -> None: ... |
| def get_connectionstyle(self) -> ConnectionStyle: ... |
| def set_arrowstyle(self, arrowstyle: str | ArrowStyle | None = ..., **kwargs) -> None: ... |
| def get_arrowstyle(self) -> ArrowStyle: ... |
| def set_mutation_scale(self, scale: float) -> None: ... |
| def get_mutation_scale(self) -> float: ... |
| def set_mutation_aspect(self, aspect: float | None) -> None: ... |
| def get_mutation_aspect(self) -> float: ... |
|
|
| class ConnectionPatch(FancyArrowPatch): |
| xy1: tuple[float, float] |
| xy2: tuple[float, float] |
| coords1: str | Transform |
| coords2: str | Transform | None |
| axesA: Axes | None |
| axesB: Axes | None |
| def __init__( |
| self, |
| xyA: tuple[float, float], |
| xyB: tuple[float, float], |
| coordsA: str | Transform, |
| coordsB: str | Transform | None = ..., |
| *, |
| axesA: Axes | None = ..., |
| axesB: Axes | None = ..., |
| arrowstyle: str | ArrowStyle = ..., |
| connectionstyle: str | ConnectionStyle = ..., |
| patchA: Patch | None = ..., |
| patchB: Patch | None = ..., |
| shrinkA: float = ..., |
| shrinkB: float = ..., |
| mutation_scale: float = ..., |
| mutation_aspect: float | None = ..., |
| clip_on: bool = ..., |
| **kwargs, |
| ) -> None: ... |
| def set_annotation_clip(self, b: bool | None) -> None: ... |
| def get_annotation_clip(self) -> bool | None: ... |
|
|
