| | 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: ... |
| |
|
