SYMBOL INDEX (595 symbols across 65 files)

FILE: chalk/align.py
  function align_to (line 7) | def align_to(self: Diagram, v: V2) -> Diagram:
  function snug (line 13) | def snug(self: Diagram, v: V2) -> Diagram:
  function center (line 22) | def center(self: Diagram) -> Diagram:
  function align_t (line 29) | def align_t(self: Diagram) -> Diagram:
  function align_b (line 33) | def align_b(self: Diagram) -> Diagram:
  function align_r (line 37) | def align_r(self: Diagram) -> Diagram:
  function align_l (line 41) | def align_l(self: Diagram) -> Diagram:
  function align_tl (line 45) | def align_tl(self: Diagram) -> Diagram:
  function align_br (line 49) | def align_br(self: Diagram) -> Diagram:
  function align_tr (line 53) | def align_tr(self: Diagram) -> Diagram:
  function align_bl (line 57) | def align_bl(self: Diagram) -> Diagram:
  function center_xy (line 61) | def center_xy(self: Diagram) -> Diagram:
  function scale_uniform_to_x (line 69) | def scale_uniform_to_x(self: Diagram, x: float) -> Diagram:
  function scale_uniform_to_y (line 86) | def scale_uniform_to_y(self: Diagram, y: float) -> Diagram:

FILE: chalk/arrow.py
  class ArrowOpts (line 18) | class ArrowOpts:
  function connect (line 31) | def connect(
  function connect_outside (line 45) | def connect_outside(
  function connect_perim (line 71) | def connect_perim(
  function arrow (line 102) | def arrow(length: float, style: ArrowOpts = ArrowOpts()) -> Diagram:
  function arrow_v (line 133) | def arrow_v(vec: V2, style: ArrowOpts = ArrowOpts()) -> Diagram:
  function arrow_at (line 138) | def arrow_at(base: P2, vec: V2, style: ArrowOpts = ArrowOpts()) -> Diagram:
  function arrow_between (line 142) | def arrow_between(

FILE: chalk/backend/cairo.py
  function tx_to_cairo (line 32) | def tx_to_cairo(affine: Affine) -> Any:
  class ToList (line 41) | class ToList(DiagramVisitor[MList[Any], Affine]):
    method visit_primitive (line 48) | def visit_primitive(
    method visit_apply_transform (line 53) | def visit_apply_transform(
    method visit_apply_style (line 64) | def visit_apply_style(
    method visit_apply_name (line 74) | def visit_apply_name(
  class ToCairoShape (line 80) | class ToCairoShape(ShapeVisitor[None]):
    method render_segment (line 82) | def render_segment(
    method visit_path (line 101) | def visit_path(
    method visit_latex (line 117) | def visit_latex(
    method visit_text (line 125) | def visit_text(
    method visit_spacer (line 139) | def visit_spacer(
    method visit_arrowhead (line 147) | def visit_arrowhead(
    method visit_image (line 157) | def visit_image(
  function render_cairo_prims (line 170) | def render_cairo_prims(
  function render (line 188) | def render(

FILE: chalk/backend/svg.py
  function tx_to_svg (line 42) | def tx_to_svg(affine: tx.Affine) -> str:
  class Raw (line 51) | class Raw(Rect):  # type: ignore
    method __init__ (line 57) | def __init__(self, st: str):
    method get_xml (line 61) | def get_xml(self) -> ET.Element:
  class ToSVG (line 65) | class ToSVG(DiagramVisitor[BaseElement, Style]):
    method __init__ (line 68) | def __init__(self, dwg: Drawing):
    method visit_primitive (line 72) | def visit_primitive(
    method visit_empty (line 88) | def visit_empty(
    method visit_compose (line 93) | def visit_compose(
    method visit_apply_transform (line 102) | def visit_apply_transform(
    method visit_apply_style (line 109) | def visit_apply_style(
    method visit_apply_name (line 114) | def visit_apply_name(
  class ToSVGShape (line 122) | class ToSVGShape(ShapeVisitor[BaseElement]):
    method __init__ (line 123) | def __init__(self, dwg: Drawing):
    method render_segment (line 126) | def render_segment(self, seg: SegmentLike, p: P2) -> str:
    method visit_path (line 137) | def visit_path(
    method visit_latex (line 155) | def visit_latex(
    method visit_text (line 163) | def visit_text(
    method visit_spacer (line 178) | def visit_spacer(
    method visit_arrowhead (line 183) | def visit_arrowhead(
    method visit_image (line 190) | def visit_image(
  function to_svg (line 200) | def to_svg(self: Diagram, dwg: Drawing, style: Style) -> BaseElement:
  function render (line 204) | def render(

FILE: chalk/backend/tikz.py
  function tx_to_tikz (line 33) | def tx_to_tikz(affine: tx.Affine) -> str:
  class ToTikZ (line 42) | class ToTikZ(DiagramVisitor[MList[PyLatexElement], Style]):
    method __init__ (line 45) | def __init__(self, pylatex: PyLatex):
    method visit_primitive (line 49) | def visit_primitive(
    method visit_apply_transform (line 65) | def visit_apply_transform(
    method visit_apply_style (line 74) | def visit_apply_style(
  class ToTikZShape (line 81) | class ToTikZShape(ShapeVisitor[PyLatexElement]):
    method __init__ (line 82) | def __init__(self, pylatex: PyLatex):
    method render_segment (line 85) | def render_segment(
    method visit_path (line 109) | def visit_path(
    method visit_latex (line 129) | def visit_latex(
    method visit_text (line 134) | def visit_text(
    method visit_spacer (line 152) | def visit_spacer(
    method visit_arrowhead (line 167) | def visit_arrowhead(
    method visit_image (line 179) | def visit_image(
  function to_tikz (line 185) | def to_tikz(
  function render (line 191) | def render(self: Diagram, path: str, height: int = 128) -> None:

FILE: chalk/combinators.py
  function with_envelope (line 12) | def with_envelope(self: Diagram, other: Diagram) -> Diagram:
  function strut (line 19) | def strut(width: float, height: float) -> Diagram:
  function pad (line 25) | def pad(self: Diagram, extra: float) -> Diagram:
  function frame (line 47) | def frame(self: Diagram, extra: float) -> Diagram:
  function atop (line 71) | def atop(self: Diagram, other: Diagram) -> Diagram:
  function above (line 81) | def above(self: Diagram, other: Diagram) -> Diagram:
  function beside (line 88) | def beside(self: Diagram, other: Diagram, direction: V2) -> Diagram:
  function place_at (line 92) | def place_at(
  function place_on_path (line 98) | def place_on_path(diagrams: Iterable[Diagram], path: Path) -> Diagram:
  function cat (line 105) | def cat(
  function concat (line 121) | def concat(diagrams: Iterable[Diagram]) -> Diagram:
  function empty (line 137) | def empty() -> Diagram:
  function hstrut (line 149) | def hstrut(width: Optional[float]) -> Diagram:
  function vstrut (line 157) | def vstrut(height: Optional[float]) -> Diagram:
  function hcat (line 165) | def hcat(diagrams: Iterable[Diagram], sep: Optional[float] = None) -> Di...
  function vcat (line 180) | def vcat(diagrams: Iterable[Diagram], sep: Optional[float] = None) -> Di...
  function above2 (line 198) | def above2(self: Diagram, other: Diagram) -> Diagram:
  function juxtapose_snug (line 215) | def juxtapose_snug(self: Diagram, other: Diagram, direction: V2) -> Diag...
  function beside_snug (line 226) | def beside_snug(self: Diagram, other: Diagram, direction: V2) -> Diagram:
  function juxtapose (line 230) | def juxtapose(self: Diagram, other: Diagram, direction: V2) -> Diagram:
  function at_center (line 249) | def at_center(self: Diagram, other: Diagram) -> Diagram:

FILE: chalk/core.py
  function set_svg_height (line 35) | def set_svg_height(height: int) -> None:
  function set_svg_draw_height (line 41) | def set_svg_draw_height(height: int) -> None:
  class BaseDiagram (line 48) | class BaseDiagram(chalk.types.Diagram):
    method empty (line 55) | def empty(cls) -> Diagram:  # type: ignore
    method apply_transform (line 59) | def apply_transform(self, t: Affine) -> Diagram:  # type: ignore
    method apply_style (line 63) | def apply_style(self, style: Style) -> Diagram:  # type: ignore
    method _style (line 66) | def _style(self, style: Style) -> Diagram:
    method compose (line 69) | def compose(
    method named (line 82) | def named(self, name: Name) -> Diagram:
    method __or__ (line 127) | def __or__(self, d: Diagram) -> Diagram:
    method display (line 133) | def display(
    method _repr_svg_ (line 157) | def _repr_svg_(self) -> str:
    method _repr_html_ (line 166) | def _repr_html_(self) -> str | tuple[str, Any]:
    method qualify (line 178) | def qualify(self, name: Name) -> Diagram:
    method accept (line 182) | def accept(self, visitor: DiagramVisitor[A, Any], args: Any) -> A:
  class Primitive (line 187) | class Primitive(BaseDiagram):
    method from_shape (line 200) | def from_shape(cls, shape: Shape) -> Primitive:
    method apply_transform (line 212) | def apply_transform(self, t: Affine) -> Primitive:
    method apply_style (line 224) | def apply_style(self, other_style: Style) -> Primitive:
    method accept (line 237) | def accept(self, visitor: DiagramVisitor[A, Any], args: Any) -> A:
  class Empty (line 242) | class Empty(BaseDiagram):
    method accept (line 245) | def accept(self, visitor: DiagramVisitor[A, Any], args: Any) -> A:
  class Compose (line 250) | class Compose(BaseDiagram):
    method accept (line 256) | def accept(self, visitor: DiagramVisitor[A, Any], args: Any) -> A:
  class ApplyTransform (line 261) | class ApplyTransform(BaseDiagram):
    method accept (line 267) | def accept(self, visitor: DiagramVisitor[A, Any], args: Any) -> A:
  class ApplyStyle (line 272) | class ApplyStyle(BaseDiagram):
    method accept (line 278) | def accept(self, visitor: DiagramVisitor[A, Any], args: Any) -> A:
  class ApplyName (line 283) | class ApplyName(BaseDiagram):
    method accept (line 289) | def accept(self, visitor: DiagramVisitor[A, Any], args: Any) -> A:
  class Qualify (line 293) | class Qualify(DiagramVisitor[Diagram, None]):
    method __init__ (line 296) | def __init__(self, name: Name):
    method visit_primitive (line 299) | def visit_primitive(self, diagram: Primitive, args: None) -> Diagram:
    method visit_compose (line 302) | def visit_compose(self, diagram: Compose, args: None) -> Diagram:
    method visit_apply_transform (line 307) | def visit_apply_transform(
    method visit_apply_style (line 315) | def visit_apply_style(self, diagram: ApplyStyle, args: None) -> Diagram:
    method visit_apply_name (line 321) | def visit_apply_name(self, diagram: ApplyName, args: None) -> Diagram:

FILE: chalk/envelope.py
  class Envelope (line 30) | class Envelope(Transformable, Monoid):
    method __init__ (line 31) | def __init__(
    method __call__ (line 37) | def __call__(self, direction: V2) -> SignedDistance:
    method empty (line 43) | def empty() -> Envelope:
    method __add__ (line 46) | def __add__(self, other: Envelope) -> Envelope:
    method center (line 56) | def center(self) -> P2:
    method width (line 65) | def width(self) -> float:
    method height (line 70) | def height(self) -> float:
    method apply_transform (line 74) | def apply_transform(self, t: Affine) -> Envelope:
    method envelope_v (line 97) | def envelope_v(self, v: V2) -> V2:
    method from_bounding_box (line 105) | def from_bounding_box(box: BoundingBox) -> Envelope:
    method from_circle (line 115) | def from_circle(radius: float) -> Envelope:
    method to_path (line 121) | def to_path(self, angle: int = 45) -> Iterable[P2]:
    method to_segments (line 129) | def to_segments(self, angle: int = 45) -> Iterable[Tuple[P2, P2]]:
  class GetEnvelope (line 138) | class GetEnvelope(DiagramVisitor[Envelope, Affine]):
    method visit_primitive (line 141) | def visit_primitive(
    method visit_compose (line 147) | def visit_compose(self, diagram: Compose, t: Affine = Ident) -> Envelope:
    method visit_apply_transform (line 150) | def visit_apply_transform(
  function get_envelope (line 157) | def get_envelope(self: Diagram, t: Affine = Ident) -> Envelope:

FILE: chalk/model.py
  function show_origin (line 13) | def show_origin(self: Diagram) -> Diagram:
  function show_envelope (line 24) | def show_envelope(
  function show_beside (line 60) | def show_beside(self: Diagram, other: Diagram, direction: V2) -> Diagram:
  function show_labels (line 97) | def show_labels(self: Diagram, font_size: int = 1) -> Diagram:

FILE: chalk/monoid.py
  function associative_reduce (line 19) | def associative_reduce(
  class Monoid (line 37) | class Monoid:
    method empty (line 39) | def empty(cls) -> Self:
    method __add__ (line 42) | def __add__(self, other: Self) -> Self:
    method concat (line 46) | def concat(cls, elems: Iterable[Self]) -> Self:
  class Maybe (line 54) | class Maybe(Generic[A], Monoid):
    method empty (line 58) | def empty(cls) -> Maybe[A]:
    method __add__ (line 61) | def __add__(self, other: Maybe[A]) -> Maybe[A]:
  class MList (line 68) | class MList(Generic[A], Monoid):
    method empty (line 72) | def empty(cls) -> MList[A]:
    method __add__ (line 75) | def __add__(self, other: MList[A]) -> MList[A]:
    method __iter__ (line 78) | def __iter__(self) -> Iterator[A]:

FILE: chalk/shapes/__init__.py
  function hrule (line 18) | def hrule(length: float) -> Diagram:
  function vrule (line 22) | def vrule(length: float) -> Diagram:
  function regular_polygon (line 41) | def regular_polygon(sides: int, side_length: float) -> Diagram:
  function triangle (line 47) | def triangle(width: float) -> Diagram:
  function rectangle (line 53) | def rectangle(
  function square (line 75) | def square(side: float) -> Diagram:
  function circle (line 81) | def circle(radius: float) -> Diagram:
  function arc (line 86) | def arc(radius: float, angle0: float, angle1: float) -> Diagram:
  function arc_between (line 107) | def arc_between(

FILE: chalk/shapes/arc.py
  function is_in_mod_360 (line 29) | def is_in_mod_360(x: Degrees, a: Degrees, b: Degrees) -> bool:
  class LocatedArcSegment (line 38) | class LocatedArcSegment(Traceable, Enveloped, tx.Transformable):
    method p (line 48) | def p(self) -> P2:
    method q (line 53) | def q(self) -> P2:
    method q_angle (line 60) | def q_angle(self) -> float:
    method center (line 64) | def center(self) -> P2:
    method r_x (line 69) | def r_x(self) -> float:
    method r_y (line 74) | def r_y(self) -> float:
    method rot (line 79) | def rot(self) -> float:
    method get_trace (line 83) | def get_trace(self, t: tx.Affine = Ident) -> Trace:
    method get_envelope (line 104) | def get_envelope(self, t: tx.Affine = Ident) -> Envelope:
    method arc_between (line 129) | def arc_between(
  class ArcSegment (line 165) | class ArcSegment(LocatedArcSegment, TrailLike):
    method __post_init__ (line 168) | def __post_init__(self) -> None:
    method apply_transform (line 173) | def apply_transform(self, t: tx.Affine) -> ArcSegment:
    method to_trail (line 177) | def to_trail(self) -> Trail:
    method arc_between_trail (line 183) | def arc_between_trail(q: P2, height: float) -> Trail:
    method reverse (line 192) | def reverse(self) -> ArcSegment:
  function arc_seg (line 198) | def arc_seg(q: V2, height: float) -> Trail:
  function arc_seg_angle (line 202) | def arc_seg_angle(angle: float, dangle: float) -> Trail:

FILE: chalk/shapes/arrowheads.py
  function tri (line 15) | def tri() -> Diagram:
  function dart (line 29) | def dart(cut: float = 0.2) -> Diagram:
  class ArrowHead (line 51) | class ArrowHead(Shape):
    method get_bounding_box (line 56) | def get_bounding_box(self) -> BoundingBox:
    method accept (line 63) | def accept(self, visitor: ShapeVisitor[A], **kwargs: Any) -> A:

FILE: chalk/shapes/image.py
  function from_pil (line 13) | def from_pil(
  class Image (line 30) | class Image(Shape):
    method __post_init__ (line 36) | def __post_init__(self) -> None:
    method get_bounding_box (line 49) | def get_bounding_box(self) -> BoundingBox:
  function image (line 57) | def image(local_path: str, url_path: Optional[str]) -> Diagram:

FILE: chalk/shapes/latex.py
  class Latex (line 11) | class Latex(Shape):
    method __post_init__ (line 16) | def __post_init__(self) -> None:
    method get_bounding_box (line 46) | def get_bounding_box(self) -> BoundingBox:
    method accept (line 51) | def accept(self, visitor: ShapeVisitor[A], **kwargs: Any) -> A:
  function latex (line 55) | def latex(t: str) -> Diagram:

FILE: chalk/shapes/path.py
  function make_path (line 16) | def make_path(
  class Path (line 23) | class Path(Shape, Enveloped, Traceable, Transformable):
    method empty (line 30) | def empty() -> Path:
    method __add__ (line 33) | def __add__(self, other: Path) -> Path:
    method apply_transform (line 36) | def apply_transform(self, t: tx.Affine) -> Path:
    method points (line 41) | def points(self) -> Iterable[P2]:
    method get_envelope (line 46) | def get_envelope(self) -> Envelope:
    method get_trace (line 49) | def get_trace(self) -> Trace:
    method accept (line 52) | def accept(self, visitor: ShapeVisitor[A], **kwargs: Any) -> A:
    method from_points (line 57) | def from_points(points: List[P2], closed: bool = False) -> Path:
    method from_point (line 67) | def from_point(point: P2) -> Path:
    method from_pairs (line 71) | def from_pairs(segs: List[Tuple[P2, P2]], closed: bool = False) -> Path:
    method from_list_of_tuples (line 81) | def from_list_of_tuples(

FILE: chalk/shapes/segment.py
  class LocatedSegment (line 25) | class LocatedSegment(Traceable, Enveloped, tx.Transformable, TrailLike):
    method p (line 30) | def p(self) -> P2:
    method from_points (line 34) | def from_points(p: P2, q: P2) -> LocatedSegment:
    method apply_transform (line 37) | def apply_transform(self, t: tx.Affine) -> LocatedSegment:
    method q (line 43) | def q(self) -> P2:
    method get_trace (line 46) | def get_trace(self, t: tx.Affine = Ident) -> Trace:
    method get_envelope (line 54) | def get_envelope(self, t: tx.Affine = Ident) -> Envelope:
    method length (line 62) | def length(self) -> Any:
    method to_ray (line 65) | def to_ray(self) -> "Ray":
    method to_trail (line 68) | def to_trail(self) -> Trail:
  class Segment (line 75) | class Segment(LocatedSegment, TrailLike):
    method p (line 77) | def p(self) -> P2:
    method apply_transform (line 80) | def apply_transform(self, t: tx.Affine) -> Segment:
    method reverse (line 83) | def reverse(self):  # type: ignore
  function seg (line 87) | def seg(offset: V2) -> Trail:
  function ray_ray_intersection (line 91) | def ray_ray_intersection(
  function line_segment (line 119) | def line_segment(ray: Ray, segment: LocatedSegment) -> List[float]:
  function ray_circle_intersection (line 150) | def ray_circle_intersection(ray: Ray, circle_radius: float) -> List[float]:

FILE: chalk/shapes/shape.py
  class Shape (line 15) | class Shape:
    method get_bounding_box (line 18) | def get_bounding_box(self) -> BoundingBox:
    method get_envelope (line 21) | def get_envelope(self) -> Envelope:
    method get_trace (line 24) | def get_trace(self) -> Trace:
    method accept (line 33) | def accept(self, visitor: ShapeVisitor[A], **kwargs: Any) -> A:
    method stroke (line 36) | def stroke(self) -> Diagram:
  class Spacer (line 48) | class Spacer(Shape):
    method get_bounding_box (line 54) | def get_bounding_box(self) -> BoundingBox:
    method accept (line 61) | def accept(self, visitor: ShapeVisitor[A], **kwargs: Any) -> A:

FILE: chalk/shapes/text.py
  class Text (line 11) | class Text(Shape):
    method get_bounding_box (line 17) | def get_bounding_box(self) -> BoundingBox:
    method accept (line 24) | def accept(self, visitor: ShapeVisitor[A], **kwargs: Any) -> A:
  function text (line 28) | def text(t: str, size: Optional[float]) -> Diagram:

FILE: chalk/style.py
  class Stylable (line 14) | class Stylable:
    method line_width (line 15) | def line_width(self, width: float) -> Self:
    method line_width_local (line 20) | def line_width_local(self, width: float) -> Self:
    method line_color (line 23) | def line_color(self, color: Color) -> Self:
    method fill_color (line 26) | def fill_color(self, color: Color) -> Self:
    method fill_opacity (line 29) | def fill_opacity(self, opacity: float) -> Self:
    method dashing (line 32) | def dashing(self, dashing_strokes: List[float], offset: float) -> Self:
    method apply_style (line 35) | def apply_style(self: Self, style: Style) -> Self:
  function m (line 39) | def m(a: Optional[Any], b: Optional[Any]) -> Optional[Any]:
  class WidthType (line 43) | class WidthType(Enum):
  class Style (line 53) | class Style(Stylable):
    method empty (line 64) | def empty(cls) -> Style:
    method root (line 68) | def root(cls, output_size: float) -> Style:
    method apply_style (line 71) | def apply_style(self, other: Style) -> Style:
    method merge (line 74) | def merge(self, other: Style) -> Style:
    method render (line 90) | def render(self, ctx: PyCairoContext) -> None:
    method to_svg (line 128) | def to_svg(self) -> str:
    method to_tikz (line 166) | def to_tikz(self, pylatex: PyLatex) -> Dict[str, str]:

FILE: chalk/subdiagram.py
  class Name (line 22) | class Name:
    method __init__ (line 25) | def __init__(self, atomic_name: AtomicName):
    method __hash__ (line 28) | def __hash__(self) -> int:
    method __str__ (line 31) | def __str__(self) -> str:
    method __add__ (line 34) | def __add__(self, other: Name) -> Name:
    method qualify (line 39) | def qualify(self, name: Name) -> Name:
  class Subdiagram (line 44) | class Subdiagram(Monoid):
    method get_location (line 49) | def get_location(self) -> P2:
    method get_envelope (line 52) | def get_envelope(self) -> Envelope:
    method get_trace (line 55) | def get_trace(self) -> Trace:
    method boundary_from (line 58) | def boundary_from(self, v: V2) -> P2:
  class GetSubdiagram (line 71) | class GetSubdiagram(DiagramVisitor[Maybe[Subdiagram], Affine]):
    method __init__ (line 74) | def __init__(self, name: Name, t: Affine = Ident):
    method visit_compose (line 77) | def visit_compose(
    method visit_apply_transform (line 88) | def visit_apply_transform(
    method visit_apply_name (line 95) | def visit_apply_name(
  function get_subdiagram (line 106) | def get_subdiagram(self: Diagram, name: Name) -> Optional[Subdiagram]:
  function with_names (line 110) | def with_names(
  class SubMap (line 132) | class SubMap(Monoid):
    method __add__ (line 135) | def __add__(self, other: SubMap) -> SubMap:
    method empty (line 143) | def empty(cls) -> SubMap:
  class GetSubMap (line 147) | class GetSubMap(DiagramVisitor[SubMap, Affine]):
    method visit_apply_transform (line 150) | def visit_apply_transform(
    method visit_apply_name (line 157) | def visit_apply_name(
  function get_sub_map (line 167) | def get_sub_map(

FILE: chalk/trace.py
  class Trace (line 25) | class Trace(Monoid, Transformable):
    method __init__ (line 26) | def __init__(self, f: Callable[[P2, V2], List[SignedDistance]]) -> None:
    method __call__ (line 29) | def __call__(self, point: P2, direction: V2) -> List[SignedDistance]:
    method empty (line 34) | def empty(cls) -> Trace:
    method __add__ (line 37) | def __add__(self, other: Trace) -> Trace:
    method apply_transform (line 44) | def apply_transform(self, t: Affine) -> Trace:
    method trace_v (line 53) | def trace_v(self, p: P2, v: V2) -> Optional[V2]:
    method trace_p (line 62) | def trace_p(self, p: P2, v: V2) -> Optional[P2]:
    method max_trace_v (line 66) | def max_trace_v(self, p: P2, v: V2) -> Optional[V2]:
    method max_trace_p (line 69) | def max_trace_p(self, p: P2, v: V2) -> Optional[P2]:
  class GetTrace (line 74) | class GetTrace(DiagramVisitor[Trace, Affine]):
    method visit_primitive (line 77) | def visit_primitive(self, diagram: Primitive, t: Affine = Ident) -> Tr...
    method visit_apply_transform (line 81) | def visit_apply_transform(
  function get_trace (line 87) | def get_trace(self: Diagram, t: Affine = Ident) -> Trace:

FILE: chalk/trail.py
  class Located (line 31) | class Located(Enveloped, Traceable, Transformable):
    method located_segments (line 35) | def located_segments(self) -> Iterable[Tuple[SegmentLike, P2]]:
    method points (line 38) | def points(self) -> Iterable[P2]:
    method get_envelope (line 41) | def get_envelope(self) -> Envelope:
    method get_trace (line 47) | def get_trace(self) -> Trace:
    method stroke (line 53) | def stroke(self) -> Diagram:
    method apply_transform (line 56) | def apply_transform(self, t: Affine) -> Located:
    method to_path (line 61) | def to_path(self) -> Path:
  class Trail (line 68) | class Trail(Monoid, Transformable, TrailLike):
    method empty (line 74) | def empty() -> Trail:
    method __add__ (line 77) | def __add__(self, other: Trail) -> Trail:
    method apply_transform (line 82) | def apply_transform(self, t: Affine) -> Trail:
    method to_trail (line 89) | def to_trail(self) -> Trail:
    method close (line 92) | def close(self) -> Trail:
    method points (line 95) | def points(self) -> Iterable[P2]:
    method at (line 103) | def at(self, p: P2) -> Located:
    method reverse (line 106) | def reverse(self) -> Trail:
    method centered (line 112) | def centered(self) -> Located:
    method from_offsets (line 117) | def from_offsets(offsets: List[V2], closed: bool = False) -> Trail:
    method hrule (line 121) | def hrule(length: float) -> Trail:
    method vrule (line 125) | def vrule(length: float) -> Trail:
    method rectangle (line 129) | def rectangle(width: float, height: float) -> Trail:
    method rounded_rectangle (line 134) | def rounded_rectangle(width: float, height: float, radius: float) -> T...
    method circle (line 146) | def circle(radius: float = 1.0, clockwise: bool = True) -> Trail:
    method regular_polygon (line 165) | def regular_polygon(sides: int, side_length: float) -> Trail:

FILE: chalk/transform.py
  function from_radians (line 9) | def from_radians(θ: float) -> float:
  function to_radians (line 14) | def to_radians(θ: float) -> float:
  function remove_translation (line 19) | def remove_translation(aff: Affine) -> Affine:
  function remove_linear (line 24) | def remove_linear(aff: Affine) -> Affine:
  function transpose_translation (line 29) | def transpose_translation(aff: Affine) -> Affine:
  function apply_affine (line 34) | def apply_affine(aff: Affine, x: Any) -> Any:
  class Transformable (line 38) | class Transformable:
    method apply_transform (line 41) | def apply_transform(self, t: Affine) -> Self:  # type: ignore[empty-body]
    method __rmul__ (line 44) | def __rmul__(self, t: Affine) -> Self:
    method _app (line 47) | def _app(self, t: Affine) -> Self:
    method scale (line 50) | def scale(self, α: float) -> Self:
    method scale_x (line 53) | def scale_x(self, α: float) -> Self:
    method scale_y (line 56) | def scale_y(self, α: float) -> Self:
    method rotate (line 59) | def rotate(self, θ: float) -> Self:
    method rotate_rad (line 63) | def rotate_rad(self, θ: float) -> Self:
    method rotate_by (line 67) | def rotate_by(self, turns: float) -> Self:
    method reflect_x (line 72) | def reflect_x(self) -> Self:
    method reflect_y (line 75) | def reflect_y(self) -> Self:
    method shear_y (line 78) | def shear_y(self, λ: float) -> Self:
    method shear_x (line 81) | def shear_x(self, λ: float) -> Self:
    method translate (line 84) | def translate(self, dx: float, dy: float) -> Self:
    method translate_by (line 87) | def translate_by(self, vector) -> Self:  # type: ignore
  function apply_p2_affine (line 119) | def apply_p2_affine(aff: Affine, x: Point) -> Point:
  function affine (line 124) | def affine(affine: Affine, other: Any) -> Any:

FILE: chalk/types.py
  class Enveloped (line 21) | class Enveloped(Protocol):
    method get_envelope (line 22) | def get_envelope(self) -> Envelope: ...
  class Traceable (line 25) | class Traceable(Protocol):
    method get_trace (line 26) | def get_trace(self) -> Trace: ...
  class Shape (line 29) | class Shape(Enveloped, Traceable, Protocol):
    method accept (line 30) | def accept(self, visitor: ShapeVisitor[A], **kwargs: Any) -> A: ...
  class TrailLike (line 33) | class TrailLike(Protocol):
    method to_trail (line 34) | def to_trail(self) -> Trail: ...
    method to_path (line 36) | def to_path(self, location: P2 = P2(0, 0)) -> Path:
    method at (line 39) | def at(self, location: P2) -> Located:
    method stroke (line 42) | def stroke(self) -> Diagram:
  class Diagram (line 46) | class Diagram(Enveloped, Traceable, Stylable, tx.Transformable, Monoid):
    method apply_transform (line 47) | def apply_transform(self, t: tx.Affine) -> Diagram:  # type: ignore[em...
    method __add__ (line 50) | def __add__(self: Diagram, other: Diagram) -> Diagram:  # type: ignore...
    method __or__ (line 53) | def __or__(self, d: Diagram) -> Diagram:  # type: ignore[empty-body]
    method __truediv__ (line 56) | def __truediv__(self, d: Diagram) -> Diagram:  # type: ignore[empty-body]
    method __floordiv__ (line 59) | def __floordiv__(self, d: Diagram) -> Diagram:  # type: ignore[empty-b...
    method juxtapose_snug (line 62) | def juxtapose_snug(  # type: ignore[empty-body]
    method beside_snug (line 66) | def beside_snug(  # type: ignore[empty-body]
    method juxtapose (line 70) | def juxtapose(  # type: ignore[empty-body]
    method atop (line 74) | def atop(self: Diagram, other: Diagram) -> Diagram:  # type: ignore[em...
    method above (line 77) | def above(self: Diagram, other: Diagram) -> Diagram:  # type: ignore[e...
    method beside (line 80) | def beside(  # type: ignore[empty-body]
    method frame (line 84) | def frame(self, extra: float) -> Diagram:  # type: ignore[empty-body]
    method pad (line 87) | def pad(self, extra: float) -> Diagram:  # type: ignore[empty-body]
    method scale_uniform_to_x (line 90) | def scale_uniform_to_x(self, x: float) -> Diagram:  # type: ignore[emp...
    method scale_uniform_to_y (line 93) | def scale_uniform_to_y(self, y: float) -> Diagram:  # type: ignore[emp...
    method align (line 96) | def align(self: Diagram, v: V2) -> Diagram:  # type: ignore[empty-body]
    method align_t (line 99) | def align_t(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method align_b (line 102) | def align_b(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method align_l (line 105) | def align_l(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method align_r (line 108) | def align_r(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method align_tl (line 111) | def align_tl(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method align_tr (line 114) | def align_tr(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method align_bl (line 117) | def align_bl(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method align_br (line 120) | def align_br(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method snug (line 123) | def snug(self: Diagram, v: V2) -> Diagram:  # type: ignore[empty-body]
    method center_xy (line 126) | def center_xy(self: Diagram) -> Diagram:  # type: ignore[empty-body]
    method get_subdiagram (line 129) | def get_subdiagram(self, name: Name) -> Optional[Subdiagram]: ...
    method get_sub_map (line 131) | def get_sub_map(  # type: ignore[empty-body]
    method with_names (line 135) | def with_names(  # type: ignore[empty-body]
    method _style (line 141) | def _style(self, style: Style) -> Diagram:  # type: ignore[empty-body]
    method with_envelope (line 144) | def with_envelope(self, other: Diagram) -> Diagram:  # type: ignore[em...
    method show_origin (line 147) | def show_origin(self) -> Diagram:  # type: ignore[empty-body]
    method show_envelope (line 150) | def show_envelope(  # type: ignore[empty-body]
    method compose (line 154) | def compose(  # type: ignore[empty-body]
    method to_list (line 158) | def to_list(  # type: ignore[empty-body]
    method accept (line 162) | def accept(  # type: ignore[empty-body]

FILE: chalk/utils.py
  function show (line 50) | def show(filepath: str) -> None:
  function imgen (line 67) | def imgen(
  function create_sample_diagram (line 161) | def create_sample_diagram(
  function create_double_diagrams (line 249) | def create_double_diagrams() -> Tuple[Diagram, Diagram]:
  function quick_probe (line 260) | def quick_probe(

FILE: chalk/visitor.py
  class DiagramVisitor (line 26) | class DiagramVisitor(Generic[A, B]):
    method visit_primitive (line 29) | def visit_primitive(self, diagram: Primitive, arg: B) -> A:
    method visit_empty (line 33) | def visit_empty(self, diagram: Empty, arg: B) -> A:
    method visit_compose (line 37) | def visit_compose(self, diagram: Compose, arg: B) -> A:
    method visit_apply_transform (line 43) | def visit_apply_transform(self, diagram: ApplyTransform, arg: B) -> A:
    method visit_apply_style (line 47) | def visit_apply_style(self, diagram: ApplyStyle, arg: B) -> A:
    method visit_apply_name (line 51) | def visit_apply_name(self, diagram: ApplyName, arg: B) -> A:
  class ShapeVisitor (line 59) | class ShapeVisitor(Generic[C]):
    method visit_path (line 60) | def visit_path(self, shape: Path) -> C:
    method visit_latex (line 63) | def visit_latex(self, shape: Latex) -> C:
    method visit_text (line 66) | def visit_text(self, shape: Text) -> C:
    method visit_spacer (line 69) | def visit_spacer(self, shape: Spacer) -> C:
    method visit_arrowhead (line 72) | def visit_arrowhead(self, shape: ArrowHead) -> C:
    method visit_image (line 75) | def visit_image(self, shape: Image) -> C:

FILE: docs/api/alignment.py
  function help (line 5) | def help(f):

FILE: docs/api/combinators.py
  function help (line 5) | def help(f):

FILE: docs/api/names.py
  function help (line 6) | def help(f):
  function connect (line 57) | def connect(subs, nodes):
  function attach (line 77) | def attach(subs, dia):
  function squares (line 84) | def squares():

FILE: docs/api/rendering.py
  function help (line 7) | def help(f):

FILE: docs/api/shapes.py
  function help (line 6) | def help(f):

FILE: docs/api/style.py
  function help (line 5) | def help(f):

FILE: docs/api/trails.py
  function help (line 5) | def help(f):

FILE: docs/api/transformations.py
  function help (line 5) | def help(f):

FILE: docs/assets/css-js/as-fastapi/custom.js
  function getDataBatch (line 5) | async function getDataBatch(page) {
  function getData (line 11) | async function getData() {
  function setupTermynal (line 25) | function setupTermynal() {
  function shuffle (line 133) | function shuffle(array) {
  function showRandomAnnouncement (line 145) | async function showRandomAnnouncement(groupId, timeInterval) {
  function main (line 162) | async function main() {

FILE: docs/assets/css-js/as-fastapi/termynal.js
  class Termynal (line 14) | class Termynal {
    method constructor (line 30) | constructor(container = '#termynal', options = {}) {
    method loadLines (line 52) | loadLines() {
    method init (line 74) | init() {
    method start (line 96) | async start() {
    method generateRestart (line 129) | generateRestart() {
    method generateFinish (line 142) | generateFinish() {
    method addRestart (line 157) | addRestart() {
    method addFinish (line 162) | addFinish() {
    method type (line 171) | async type(line) {
    method progress (line 187) | async progress(line) {
    method _wait (line 212) | _wait(time) {
    method lineDataToElements (line 223) | lineDataToElements(lineData) {
    method _attributes (line 238) | _attributes(line) {

FILE: docs/assets/css-js/general/js/material-extra/uml.js
  class MermaidDiv (line 21) | class MermaidDiv extends HTMLElement {
    method constructor (line 28) | constructor() {

FILE: docs/assets/css-js/pymdownx-extras/js/extra-uml.js
  function _typeof (line 1) | function _typeof(e) { return (_typeof = "function" == typeof Symbol && "...
  function e (line 1) | function e(t) { return (e = Object.setPrototypeOf ? Object.getPrototypeO...
  function t (line 1) | function t(e, n) { return (t = Object.setPrototypeOf || function (e, t) ...
  function n (line 1) | function n() { if ("undefined" == typeof Reflect || !Reflect.construct) ...
  function o (line 1) | function o(e, r, i) { return (o = n() ? Reflect.construct : function (e,...
  function r (line 1) | function r(n) { var i = "function" == typeof Map ? new Map : void 0; ret...
  function i (line 1) | function i(e, t) { if (t && ("object" === _typeof(t) || "function" == ty...
  function u (line 1) | function u() { var e; !function (e, t) { if (!(e instanceof t)) throw ne...

FILE: docs/assets/css-js/termynal/js/custom.js
  function setupTermynal (line 1) | function setupTermynal() {
  function main (line 109) | async function main() {

FILE: docs/assets/css-js/termynal/js/termynal.js
  class Termynal (line 14) | class Termynal {
    method constructor (line 30) | constructor(container = '#termynal', options = {}) {
    method loadLines (line 52) | loadLines() {
    method init (line 74) | init() {
    method start (line 96) | async start() {
    method generateRestart (line 129) | generateRestart() {
    method generateFinish (line 142) | generateFinish() {
    method addRestart (line 157) | addRestart() {
    method addFinish (line 162) | addFinish() {
    method type (line 171) | async type(line) {
    method progress (line 187) | async progress(line) {
    method _wait (line 212) | _wait(time) {
    method lineDataToElements (line 223) | lineDataToElements(lineData) {
    method _attributes (line 238) | _attributes(line) {

FILE: docs/examples/hanoi.py
  function draw_disk (line 24) | def draw_disk(n: Disk) -> Diagram:
  function draw_stack (line 34) | def draw_stack(s: Stack) -> Diagram:
  function draw_hanoi (line 41) | def draw_hanoi(state: Hanoi) -> Diagram:
  function solve_hanoi (line 48) | def solve_hanoi(num_disks: int) -> List[Move]:
  function do_move (line 62) | def do_move(move: Move, state: Hanoi) -> Hanoi:
  function state_sequence (line 79) | def state_sequence(num_disks: int) -> List[Hanoi]:
  function draw_state_sequence (line 88) | def draw_state_sequence(seq: List[Hanoi]) -> Diagram:

FILE: docs/examples/koch.py
  function koch (line 11) | def koch(n):

FILE: docs/examples/lenet.py
  function label (line 16) | def label(te):
  function cover (line 20) | def cover(d, a, b):
  function tile (line 28) | def tile(d, m, n, name = ""):
  function connect_all (line 32) | def connect_all(d, a, b):
  function cell (line 42) | def cell():
  function matrix (line 45) | def matrix(n, r, c):
  function back (line 48) | def back(r, n):
  function stack (line 54) | def stack(n, size, l, top, bot):
  function network (line 61) | def network(n, size, top, bot):

FILE: docs/examples/squares.py
  function make_square (line 12) | def make_square():
  function make_group (line 29) | def make_group(num_squares=4):

FILE: docs/examples/tensor.py
  function draw_cube (line 11) | def draw_cube():
  function draw_tensor (line 21) | def draw_tensor(depth, rows, columns):
  function t (line 36) | def t(d, r, c):
  function label (line 39) | def label(te, s=1.5):

FILE: examples/bigben.py
  function rot_cycle (line 162) | def rot_cycle(d: Diagram, times: int) -> Diagram:
  function fit_in (line 268) | def fit_in(b: Diagram, s: Diagram, frame=0.1) -> Diagram:
  function thin_line (line 284) | def thin_line(h):

FILE: examples/escher_square_limit.py
  function normalize (line 90) | def normalize(coords):
  function make_tile (line 97) | def make_tile(name):
  function quartet (line 100) | def quartet(tl, tr, bl, br):
  function cycle (line 105) | def cycle(diagram):

FILE: examples/hanoi.py
  function draw_disk (line 24) | def draw_disk(n: Disk) -> Diagram:
  function draw_stack (line 34) | def draw_stack(s: Stack) -> Diagram:
  function draw_hanoi (line 41) | def draw_hanoi(state: Hanoi) -> Diagram:
  function solve_hanoi (line 48) | def solve_hanoi(num_disks: int) -> List[Move]:
  function do_move (line 62) | def do_move(move: Move, state: Hanoi) -> Hanoi:
  function state_sequence (line 79) | def state_sequence(num_disks: int) -> List[Hanoi]:
  function draw_state_sequence (line 88) | def draw_state_sequence(seq: List[Hanoi]) -> Diagram:

FILE: examples/hex_variation.py
  function hexagon_tile (line 15) | def hexagon_tile():
  function rotated_hexagon_tile (line 24) | def rotated_hexagon_tile(n):
  function center_position (line 27) | def center_position(x, y):
  function hex_variation (line 34) | def hex_variation(num_tiles):

FILE: examples/hilbert.py
  function hilbert (line 12) | def hilbert(n):

FILE: examples/intro.py
  function sierpinski (line 47) | def sierpinski(n: int, size: int) -> Diagram:

FILE: examples/isometric.py
  function lookAt (line 14) | def lookAt(eye: ArrayLike, center: ArrayLike, up: ArrayLike):
  function scale3 (line 22) | def scale3(x, y, z):
  class D3 (line 27) | class D3:
    method to_np (line 32) | def to_np(self):
  function homogenous (line 39) | def homogenous(trails: List[List[D3]]):
  function cube (line 44) | def cube():
  function to_trail (line 58) | def to_trail(trail: ArrayLike, locations: ArrayLike):
  function project (line 70) | def project(projection, shape3, positions):

FILE: examples/koch.py
  function koch (line 11) | def koch(n):

FILE: examples/latex.py
  function box (line 9) | def box(t):
  function label (line 12) | def label(text):
  function arrow (line 15) | def arrow(text, d=True):

FILE: examples/lattice.py
  function node (line 13) | def node(i, j):

FILE: examples/lenet.py
  function label (line 16) | def label(te):
  function cover (line 20) | def cover(d, a, b, n):
  function tile (line 28) | def tile(d, m, n, name=""):
  function connect_all (line 32) | def connect_all(d, a, b):
  function cell (line 41) | def cell():
  function matrix (line 44) | def matrix(n, r, c):
  function back (line 47) | def back(r, n):
  function stack (line 53) | def stack(n, size, l, top, bot):
  function network (line 61) | def network(n, size, top, bot):

FILE: examples/logo.py
  function coord (line 11) | def coord(m):
  function from_polar (line 14) | def from_polar(r, theta):
  function mkCoords (line 17) | def mkCoords(n):
  function floret (line 20) | def floret(r):
  function florets (line 32) | def florets(m):
  function sunflower (line 35) | def sunflower(n):

FILE: examples/squares.py
  function make_square (line 12) | def make_square():
  function make_group (line 29) | def make_group(num_squares=4):

FILE: examples/subdiagrams.py
  function example1 (line 6) | def example1():
  function example2 (line 17) | def example2():
  function example3 (line 49) | def example3():

FILE: examples/tensor.py
  function draw_cube (line 11) | def draw_cube():
  function draw_tensor (line 21) | def draw_tensor(depth, rows, columns):
  function t (line 36) | def t(d, r, c):
  function label (line 39) | def label(te, s=1.5):

FILE: examples/tournament-network.py
  function make_node (line 13) | def make_node(n):

FILE: examples/tree.py
  function flip (line 13) | def flip(p=0.4):
  function sample_tree (line 16) | def sample_tree(n=1):
  function draw_tree (line 26) | def draw_tree(tree, name="", ysep=5, xsep=1):

FILE: tests/test_envelope.py
  function vectors (line 31) | def vectors(draw: DrawFn) -> V2:
  function trails (line 41) | def trails(draw: DrawFn) -> Trail:
  function paths (line 47) | def paths(draw: DrawFn) -> Diagram:
  function circles (line 52) | def circles(draw: DrawFn) -> Diagram:
  function rects (line 57) | def rects(draw: DrawFn) -> Diagram:
  function shapes (line 62) | def shapes(draw: DrawFn) -> Diagram:
  function diagrams (line 67) | def diagrams(draw: DrawFn) -> Diagram:
  function transforms (line 76) | def transforms(draw: DrawFn) -> chalk.transform.Affine:
  function test_envelope_trail (line 90) | def test_envelope_trail(diagram: Diagram, vec: V2) -> None:
  function test_pad (line 101) | def test_pad(diagram: Diagram, vec: V2) -> None:
  function test_square (line 112) | def test_square() -> None:
  function test_circle (line 123) | def test_circle() -> None:
  function test_circle_trace (line 132) | def test_circle_trace() -> None:
  function test_path_trace (line 141) | def test_path_trace() -> None:
  function test_transform (line 150) | def test_transform() -> None:

FILE: tests/test_reverse_trail.py
  function vectors (line 17) | def vectors(draw: DrawFn) -> V2:
  function transforms (line 24) | def transforms(draw: DrawFn) -> chalk.transform.Affine:
  function segment (line 39) | def segment(draw: DrawFn) -> Trail:
  function arc (line 46) | def arc(draw: DrawFn) -> Trail:
  function trails (line 56) | def trails(draw: DrawFn) -> Trail:
  function test_involution (line 65) | def test_involution(t: Trail) -> None:
  function test_order (line 71) | def test_order(t1: Trail, t2: Trail) -> None: