yaplotlib 0.1.3__py3-none-any.whl → 1.0.0__py3-none-any.whl

yaplotlib/__init__.py

@@ -0,0 +1,61 @@
+"""Yaplot 形式の描画データを作る。"""
+
+# even: stable; odd: develop
+__version__ = "1.0.0"
+
+from .core import (
+    Arrow,
+    ArrowType,
+    Circle,
+    Color,
+    Layer,
+    Line,
+    NewPage,
+    Polygon,
+    SetPalette,
+    Size,
+    Text,
+)
+from .document import YaplotDocument
+from .elements import Batch, PaletteDef, Primitive, Svg
+from .frame import Yaplot, YaplotFrame
+from .globals import Globals
+from .palettes import (
+    GradationPalettes,
+    RainbowPalettes,
+    RandomPalettes,
+    gradation_colors,
+    rainbow_colors,
+    random_colors,
+)
+from .spec import Kind
+
+__all__ = [
+    "__version__",
+    "Kind",
+    "Primitive",
+    "Batch",
+    "PaletteDef",
+    "Svg",
+    "Globals",
+    "YaplotFrame",
+    "Yaplot",
+    "YaplotDocument",
+    "random_colors",
+    "rainbow_colors",
+    "gradation_colors",
+    "Line",
+    "Text",
+    "Circle",
+    "Arrow",
+    "Polygon",
+    "Color",
+    "SetPalette",
+    "Size",
+    "Layer",
+    "ArrowType",
+    "NewPage",
+    "RandomPalettes",
+    "RainbowPalettes",
+    "GradationPalettes",
+]

yaplotlib/_writer.py

@@ -0,0 +1,356 @@
+"""要素の列を Yaplot のテキストに変換する。
+
+状態（レイヤ・色・半径・矢印）の差分はここでだけ計算する。
+フレームは状態を持たない。
+"""
+
+import operator
+from typing import Optional, Sequence, Union
+
+import numpy as np
+
+from .elements import (
+    Batch,
+    FrameBreak,
+    PaletteDef,
+    Primitive,
+    Svg,
+    _as_int,
+    _as_radius,
+)
+from .globals import Globals
+from .spec import KINDS
+
+# Yaplot 本体の初期値。色だけは線が 0、塗りが 2 と分かれているため未確定にする。
+_DEFAULT_LAYER = 1
+_DEFAULT_RADIUS = 1.0
+_DEFAULT_ARROW = 0
+
+
+def quote_text(text: str) -> str:
+    """空白や引用符を含む文字列を Yaplot の ``"..."`` にする。"""
+    if "\n" in text or "\r" in text:
+        raise ValueError("改行を含む文字列は出力できません")
+    if text == "" or any(char.isspace() or char in '"\\' for char in text):
+        escaped = text.replace("\\", "\\\\").replace('"', '\\"')
+        return f'"{escaped}"'
+    return text
+
+
+def format_command(
+    command: str,
+    points: Sequence[Sequence[float]],
+    *,
+    count: bool = False,
+    text: Optional[str] = None,
+) -> str:
+    """描画コマンド 1 行を作る。座標の末尾には従来どおり空白を付ける。"""
+    parts = [command]
+    if count:
+        parts.append(str(len(points)))
+    for point in points:
+        for coord in point:
+            parts.append(f"{float(coord):.4f}")
+    line = " ".join(parts) + " "
+    if text is not None:
+        line += " " + quote_text(text)
+    return line + "\n"
+
+
+def format_palette(index: int, rgb: Sequence[int]) -> str:
+    """``@ n r g b`` の 1 行を作る。"""
+    red, green, blue = rgb
+    return f"@ {int(index)} {int(red)} {int(green)} {int(blue)}\n"
+
+
+class _State:
+    """書き出し中の、Yaplot 側の現在の状態。"""
+
+    def __init__(self, defaults: Optional[Globals]) -> None:
+        self.layer = _DEFAULT_LAYER
+        self.radius = _DEFAULT_RADIUS
+        self.arrow = _DEFAULT_ARROW
+        self.color: Optional[int] = None
+        if defaults is not None:
+            if defaults.layer is not None:
+                self.layer = _as_int("layer", defaults.layer, 1)
+            if defaults.radius is not None:
+                self.radius = _as_radius(defaults.radius)
+            if defaults.arrow is not None:
+                self.arrow = _as_int("arrow", defaults.arrow, 0)
+            self.color = _opening_color(defaults)
+        self._initial = (self.layer, self.radius, self.arrow, self.color)
+
+    def reset(self) -> None:
+        self.layer, self.radius, self.arrow, self.color = self._initial
+
+
+def _opening_color(defaults: Globals) -> Optional[int]:
+    """global ブロックを読み終えた時点で選ばれている色。"""
+    if defaults.color is not None:
+        return _as_int("color", defaults.color, 0)
+    if not defaults.palettes:
+        return None
+    last = sorted(defaults.palettes)[-1]
+    return _as_int("palette", last, 0)
+
+
+def _lowering(kind: str, lower: bool) -> bool:
+    spec = KINDS[kind]
+    if lower and spec.lower_to:
+        return True
+    if spec.command is None:
+        raise ValueError(
+            f"{kind!r} にはまだ Yaplot のコマンドがありません。"
+            " dumps(lower=True) で線分に分解して出力できます。"
+        )
+    return False
+
+
+def _emit_style(state: _State, item: Union[Primitive, Batch], out: list[str]) -> None:
+    if item.layer is not None and item.layer != state.layer:
+        state.layer = item.layer
+        out.append(f"y {state.layer}\n")
+    if item.color is not None and item.color != state.color:
+        state.color = item.color
+        out.append(f"@ {state.color}\n")
+    if item.radius is not None and item.radius != state.radius:
+        state.radius = item.radius
+        out.append(f"r {state.radius}\n")
+    if item.arrow is not None and item.arrow != state.arrow:
+        state.arrow = item.arrow
+        out.append(f"a {state.arrow}\n")
+
+
+def _emit_primitive(state: _State, prim: Primitive, out: list[str], lower: bool) -> None:
+    spec = KINDS[prim.kind]
+    _emit_style(state, prim, out)
+    if _lowering(prim.kind, lower):
+        command = KINDS[spec.lower_to].command  # type: ignore[index]
+        points = prim.points
+        for start, end in zip(points, points[1:]):
+            out.append(format_command(command or "", (start, end)))
+        return
+    out.append(
+        format_command(
+            spec.command or "",
+            prim.points,
+            count=spec.npoints is None,
+            text=prim.text,
+        )
+    )
+
+
+def _emit_batch(state: _State, batch: Batch, out: list[str], lower: bool) -> None:
+    spec = KINDS[batch.kind]
+    lowering = _lowering(batch.kind, lower)
+    _emit_style(state, batch, out)
+    if lowering:
+        command = KINDS[spec.lower_to].command or ""  # type: ignore[union-attr]
+        if isinstance(batch.coords, np.ndarray):
+            out.append(_format_block(command, _chains_to_lines(batch.coords), None, False))
+        else:
+            for array in batch.coords:
+                for index in range(array.shape[0] - 1):
+                    out.append(format_command(command, (array[index], array[index + 1])))
+        return
+    if isinstance(batch.coords, np.ndarray):
+        out.append(
+            _format_block(spec.command or "", batch.coords, batch.texts, spec.npoints is None)
+        )
+        return
+    for index, array in enumerate(batch.coords):
+        text = None if batch.texts is None else batch.texts[index]
+        out.append(format_command(spec.command or "", array, count=True, text=text))
+
+
+def _emit_palette(state: _State, item: PaletteDef, out: list[str]) -> None:
+    out.append(format_palette(item.index, item.rgb))
+    # @ n r g b はパレット n を現在の色としても選ぶ。
+    state.color = item.index
+
+
+def _chains_to_lines(coords: np.ndarray) -> np.ndarray:
+    """(N, m, 3) の折れ線を、隣り合う頂点を結ぶ (N*(m-1), 2, 3) の線分にする。"""
+    if coords.shape[0] == 0 or coords.shape[1] < 2:
+        return np.zeros((0, 2, 3), dtype=float)
+    paired = np.stack((coords[:, :-1, :], coords[:, 1:, :]), axis=2)
+    return paired.reshape(-1, 2, 3)
+
+
+def _format_block(
+    command: str,
+    coords: np.ndarray,
+    texts: Optional[tuple[str, ...]],
+    with_count: bool,
+) -> str:
+    """(N, k, 3) をコマンドの行にまとめて整形する。"""
+    count = int(coords.shape[0])
+    if count == 0:
+        return ""
+    width = int(coords.shape[1])
+    formatted = np.char.mod("%.4f", coords.reshape(count, width * 3))
+    prefix = f"{command} {width} " if with_count else f"{command} "
+    lines: list[str] = []
+    for index in range(count):
+        line = prefix + " ".join(formatted[index].tolist()) + " "
+        if texts is not None:
+            line += " " + quote_text(texts[index])
+        lines.append(line + "\n")
+    return "".join(lines)
+
+
+def _svg_text(svg: Svg) -> str:
+    text = svg.text
+    if not text.endswith("\n"):
+        return text + "\n"
+    return text
+
+
+def render_frame(
+    items: Sequence[object],
+    svgs: Sequence[Svg],
+    defaults: Optional[Globals],
+    lower: bool = True,
+) -> str:
+    """1 フレーム分をテキストにする。末尾にフレーム区切りの空行は付けない。"""
+    state = _State(defaults)
+    out: list[str] = []
+    for item in items:
+        if isinstance(item, FrameBreak):
+            out.append("\n")
+            state.reset()
+            continue
+        if isinstance(item, PaletteDef):
+            _emit_palette(state, item, out)
+        elif isinstance(item, Batch):
+            _emit_batch(state, item, out, lower)
+        elif isinstance(item, Primitive):
+            _emit_primitive(state, item, out, lower)
+        else:
+            raise TypeError(f"フレームに置けない要素です: {type(item).__name__}")
+    for svg in svgs:
+        out.append(_svg_text(svg))
+    return "".join(out)
+
+
+def _join_frames(texts: Sequence[str]) -> str:
+    out: list[str] = []
+    last = len(texts) - 1
+    for index, text in enumerate(texts):
+        if text and not text.endswith("\n"):
+            text += "\n"
+        out.append(text)
+        if index != last:
+            out.append("\n")
+    return "".join(out)
+
+
+def render_document(defaults: Globals, frames: Sequence[object], lower: bool = True) -> str:
+    """global ブロックと全フレームを 1 つのテキストにする。"""
+    parts: list[str] = []
+    if not defaults.is_empty():
+        parts.append(render_globals(defaults))
+    rendered = [
+        render_frame(frame.items, frame.svgs, defaults, lower)  # type: ignore[attr-defined]
+        for frame in frames
+    ]
+    parts.append(_join_frames(rendered))
+    return "".join(parts)
+
+
+def render_globals(defaults: Globals) -> str:
+    """global ブロックを、終端の空行まで含めて作る。"""
+    lines = ["global\n"]
+    if defaults.reality is not None:
+        lines.append(f"reality {_int_between('reality', defaults.reality, 0, 4)}\n")
+    if defaults.splat is not None:
+        lines.append(f"splat {_int_between('splat', defaults.splat, 0, 3)}\n")
+    if defaults.fov is not None:
+        lines.append(f"fov {_float_token(_as_float('fov', defaults.fov))}\n")
+    if defaults.verbose is not None:
+        lines.append(f"verbose {_int_between('verbose', defaults.verbose, 0, 3)}\n")
+    if defaults.thickness is not None:
+        lines.append(f"thickness {_plain_int('thickness', defaults.thickness)}\n")
+    if defaults.rotation is not None:
+        lines.append("rotation " + _rotation(defaults.rotation) + "\n")
+    if defaults.fps is not None:
+        lines.append(f"fps {_float_token(_as_float('fps', defaults.fps))}\n")
+    if defaults.hide:
+        lines.append("hide " + _layers("hide", defaults.hide) + "\n")
+    if defaults.show:
+        lines.append("show " + _layers("show", defaults.show) + "\n")
+    for message in defaults.messages:
+        if not isinstance(message, str):
+            raise TypeError("message は文字列にしてください")
+        lines.append("message " + quote_text(message) + "\n")
+    if defaults.radius is not None:
+        lines.append(f"r {_as_radius(defaults.radius)}\n")
+    if defaults.layer is not None:
+        lines.append(f"y {_as_int('layer', defaults.layer, 1)}\n")
+    if defaults.arrow is not None:
+        lines.append(f"a {_as_int('arrow', defaults.arrow, 0)}\n")
+    for index in sorted(defaults.palettes):
+        item = PaletteDef(index, defaults.palettes[index])
+        lines.append(format_palette(item.index, item.rgb))
+    if defaults.color is not None:
+        color = _as_int("color", defaults.color, 0)
+        last: Optional[int] = None
+        if defaults.palettes:
+            last = _as_int("palette", sorted(defaults.palettes)[-1], 0)
+        # 直前の @ n r g b がすでにこの色を選んでいれば、繰り返し出力しない。
+        if last != color:
+            lines.append(f"@ {color}\n")
+    for svg in defaults.svgs:
+        lines.append(_svg_text(svg))
+    lines.append("\n")
+    return "".join(lines)
+
+
+def _plain_int(name: str, value: object) -> int:
+    if isinstance(value, bool):
+        raise TypeError(f"{name} は整数で指定してください")
+    try:
+        return operator.index(value)  # type: ignore[arg-type]
+    except TypeError:
+        raise TypeError(f"{name} は整数で指定してください") from None
+
+
+def _int_between(name: str, value: object, lo: int, hi: int) -> int:
+    number = _plain_int(name, value)
+    if not lo <= number <= hi:
+        raise ValueError(f"{name} は {lo}..{hi} の範囲です: {number}")
+    return number
+
+
+def _as_float(name: str, value: object) -> float:
+    if isinstance(value, bool):
+        raise TypeError(f"{name} は数値で指定してください")
+    try:
+        return float(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        raise TypeError(f"{name} は数値で指定してください") from None
+
+
+def _float_token(value: float) -> str:
+    if value == int(value) and abs(value) < 1e15:
+        return str(int(value))
+    return format(value, ".6g")
+
+
+def _rotation(value: object) -> str:
+    try:
+        numbers = tuple(_as_float("rotation", item) for item in value)  # type: ignore[union-attr]
+    except TypeError:
+        raise TypeError("rotation は 1〜3 個の数値にしてください") from None
+    if not 1 <= len(numbers) <= 3:
+        raise ValueError(f"rotation は 1〜3 個の数値にしてください（{len(numbers)} 個渡されました）")
+    return " ".join(_float_token(number) for number in numbers)
+
+
+def _layers(name: str, values: object) -> str:
+    try:
+        numbers = [_as_int(name, item, 1) for item in values]  # type: ignore[union-attr]
+    except TypeError:
+        raise TypeError(f"{name} はレイヤ番号の列にしてください") from None
+    return " ".join(str(number) for number in numbers)

yaplotlib/core.py

@@ -0,0 +1,106 @@
+"""低レベル API。1 コマンドぶんの文字列を返す。
+
+新しいコードでは :class:`yaplotlib.YaplotDocument` を使う。
+これらの関数は互換のために残してある。
+"""
+
+import warnings
+from typing import Iterable, Optional, Sequence, Union
+
+from ._writer import format_command, format_palette
+from .elements import Primitive
+
+
+def _deprecated(name: str, replacement: str) -> None:
+    warnings.warn(
+        f"yaplotlib.{name}() は非推奨です。{replacement} を使ってください。",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+
+def Line(v0: Sequence[float], v1: Sequence[float]) -> str:
+    """2 点を結ぶ線分。非推奨。"""
+    _deprecated("Line", "フレームの add('line', v0, v1)")
+    prim = Primitive("line", (v0, v1))
+    return format_command("l", prim.points)
+
+
+def Text(v: Sequence[float], txt: str) -> str:
+    """位置 v に文字列を描く。非推奨。"""
+    _deprecated("Text", "フレームの add('text', v, text=...)")
+    prim = Primitive("text", (v,), text=txt)
+    return format_command("t", prim.points, text=prim.text)
+
+
+def Circle(v0: Sequence[float]) -> str:
+    """中心 v0 に円を描く。非推奨。"""
+    _deprecated("Circle", "フレームの add('circle', v0)")
+    prim = Primitive("circle", (v0,))
+    return format_command("c", prim.points)
+
+
+def Arrow(v0: Sequence[float], v1: Sequence[float]) -> str:
+    """始点 v0、終点 v1 の棒（stick）を描く。非推奨。"""
+    _deprecated("Arrow", "フレームの add('stick', v0, v1)")
+    prim = Primitive("stick", (v0, v1))
+    return format_command("s", prim.points)
+
+
+def Polygon(vertices: Iterable[Sequence[float]]) -> str:
+    """頂点列から多角形を描く。非推奨。"""
+    _deprecated("Polygon", "フレームの add('polygon', *vertices)")
+    prim = Primitive("polygon", tuple(vertices))
+    return format_command("p", prim.points, count=True)
+
+
+def Color(x: int) -> str:
+    """パレット番号 x を選ぶ。非推奨。"""
+    _deprecated("Color", "要素の color=")
+    return f"@ {int(x)}\n"
+
+
+def SetPalette(
+    x: int,
+    R: Union[int, Sequence[float]],
+    G: Optional[float] = None,
+    B: Optional[float] = None,
+    maxval: float = 255.0,
+) -> str:
+    """パレット x の RGB を設定する。非推奨。
+
+    R, G, B は 0..maxval の範囲、または (R, G, B) の列を渡す。
+    """
+    _deprecated("SetPalette", "フレームの palette(index, rgb)")
+    if G is None:
+        R, G, B = R  # type: ignore[misc]
+    rgb = (
+        int(R * 255 / maxval),  # type: ignore[operator]
+        int(G * 255 / maxval),  # type: ignore[operator]
+        int(B * 255 / maxval),  # type: ignore[operator]
+    )
+    return format_palette(int(x), rgb)
+
+
+def Size(x: float) -> str:
+    """円や棒の半径を設定する。非推奨。"""
+    _deprecated("Size", "要素の radius=")
+    return f"r {float(x)}\n"
+
+
+def Layer(x: int) -> str:
+    """描画レイヤを設定する。非推奨。"""
+    _deprecated("Layer", "要素の layer=")
+    return f"y {int(x)}\n"
+
+
+def ArrowType(x: int) -> str:
+    """矢印のスタイルを設定する。非推奨。"""
+    _deprecated("ArrowType", "要素の arrow=")
+    return f"a {int(x)}\n"
+
+
+def NewPage() -> str:
+    """フレームの区切り。非推奨。"""
+    _deprecated("NewPage", "YaplotDocument.new_frame()")
+    return "\n"

yaplotlib/document.py

@@ -0,0 +1,162 @@
+"""複数フレームと global ブロックからなる Yaplot ドキュメント。"""
+
+from pathlib import Path
+from typing import Iterable, Iterator, Optional, Sequence, Union
+
+from ._writer import render_document
+from .frame import YaplotFrame, _deprecated
+from .globals import Globals
+
+
+class YaplotDocument:
+    """Yaplot のファイル 1 つ。
+
+    :attr:`globals` に全フレーム共通の既定値と SVG を置き、
+    :meth:`new_frame` が返すフレームに描画要素を追加する。
+    """
+
+    def __init__(self) -> None:
+        self.globals = Globals()
+        self.frames: list[YaplotFrame] = []
+
+    def new_frame(self) -> YaplotFrame:
+        """フレームを 1 つ追加して、それを返す。"""
+        frame = YaplotFrame()
+        self.frames.append(frame)
+        return frame
+
+    @property
+    def current(self) -> YaplotFrame:
+        """最後に追加したフレームを返す。"""
+        if not self.frames:
+            raise IndexError("フレームがありません。new_frame() を先に呼んでください。")
+        return self.frames[-1]
+
+    def __iter__(self) -> Iterator[YaplotFrame]:
+        return iter(self.frames)
+
+    def __len__(self) -> int:
+        return len(self.frames)
+
+    def dumps(self, *, lower: bool = True) -> str:
+        """global ブロックと全フレームをテキストにする。
+
+        ``lower`` が真のとき、polyline は線分に分解して出力する。
+        """
+        return render_document(self.globals, self.frames, lower)
+
+    def save(self, path: Union[str, Path], *, lower: bool = True) -> None:
+        """ドキュメント全体をファイルに書く。"""
+        Path(path).write_text(self.dumps(lower=lower), encoding="utf-8")
+
+    def _legacy_frame(self) -> YaplotFrame:
+        if not self.frames:
+            return self.new_frame()
+        return self.frames[-1]
+
+    # 互換 API（非推奨）。呼ばれた時点でフレームが無ければ 1 つ作る。
+    def Layer(self, layer: int) -> None:
+        _deprecated("YaplotDocument.Layer()", "要素の layer= か、global の layer")
+        self._legacy_frame().Layer(layer, _quiet=True)
+
+    def Color(self, color: int) -> None:
+        _deprecated("YaplotDocument.Color()", "要素の color=")
+        self._legacy_frame().Color(color, _quiet=True)
+
+    def Size(self, size: float) -> None:
+        _deprecated("YaplotDocument.Size()", "要素の radius=")
+        self._legacy_frame().Size(size, _quiet=True)
+
+    def ArrowType(self, arrowtype: int) -> None:
+        _deprecated("YaplotDocument.ArrowType()", "要素の arrow=")
+        self._legacy_frame().ArrowType(arrowtype, _quiet=True)
+
+    def Line(self, a: Sequence[float], b: Sequence[float], layer: int = -1, color: int = -1) -> None:
+        _deprecated("YaplotDocument.Line()", "フレームの add('line', a, b)")
+        self._legacy_frame().Line(a, b, layer, color, _quiet=True)
+
+    def Arrow(
+        self,
+        a: Sequence[float],
+        b: Sequence[float],
+        layer: int = -1,
+        color: int = -1,
+        size: float = -1,
+        arrowtype: int = -1,
+    ) -> None:
+        _deprecated("YaplotDocument.Arrow()", "フレームの add('stick', a, b, arrow=...)")
+        self._legacy_frame().Arrow(a, b, layer, color, size, arrowtype, _quiet=True)
+
+    def Polygon(self, p: Iterable[Sequence[float]], layer: int = -1, color: int = -1) -> None:
+        _deprecated("YaplotDocument.Polygon()", "フレームの add('polygon', *vertices)")
+        self._legacy_frame().Polygon(p, layer, color, _quiet=True)
+
+    def Circle(
+        self,
+        c: Sequence[float],
+        layer: int = -1,
+        color: int = -1,
+        size: float = -1,
+    ) -> None:
+        _deprecated("YaplotDocument.Circle()", "フレームの add('circle', center)")
+        self._legacy_frame().Circle(c, layer, color, size, _quiet=True)
+
+    def SetPalette(
+        self,
+        x: int,
+        R: Union[int, Sequence[float]],
+        G: Optional[float] = None,
+        B: Optional[float] = None,
+        maxval: float = 255.0,
+    ) -> None:
+        _deprecated("YaplotDocument.SetPalette()", "フレームの palette(index, rgb)")
+        self._legacy_frame().SetPalette(x, R, G, B, maxval, _quiet=True)
+
+    def GradationPalettes(
+        self,
+        N: int,
+        color: Sequence[float],
+        color1: Sequence[float],
+        offset: int = 10,
+        maxval: float = 255.0,
+    ) -> None:
+        _deprecated("YaplotDocument.GradationPalettes()", "フレームの palettes(gradation_colors(...))")
+        self._legacy_frame().GradationPalettes(N, color, color1, offset, maxval, _quiet=True)
+
+    def RandomPalettes(self, N: int, offset: int = 10) -> None:
+        _deprecated("YaplotDocument.RandomPalettes()", "フレームの palettes(random_colors(...))")
+        self._legacy_frame().RandomPalettes(N, offset, _quiet=True)
+
+    def RainbowPalettes(self, N: int, offset: int = 10) -> None:
+        _deprecated("YaplotDocument.RainbowPalettes()", "フレームの palettes(rainbow_colors(...))")
+        self._legacy_frame().RainbowPalettes(N, offset, _quiet=True)
+
+    def Points(
+        self,
+        points: Iterable[Sequence[float]],
+        layer: int = -1,
+        color: int = -1,
+        size: float = -1,
+    ) -> None:
+        _deprecated("YaplotDocument.Points()", "フレームの add_many('circle', points)")
+        self._legacy_frame().Points(points, layer, color, size, _quiet=True)
+
+    def LinesBatch(
+        self,
+        segments: Iterable[tuple[Sequence[float], Sequence[float]]],
+        layer: int = -1,
+        color: int = -1,
+    ) -> None:
+        _deprecated("YaplotDocument.LinesBatch()", "フレームの add_many('line', coords)")
+        self._legacy_frame().LinesBatch(segments, layer, color, _quiet=True)
+
+    def ArrowsBatch(
+        self,
+        segments: Iterable[tuple[Sequence[float], Sequence[float]]],
+        layer: int = -1,
+        color: int = -1,
+        size: float = -1,
+        arrowtype: int = -1,
+    ) -> None:
+        _deprecated("YaplotDocument.ArrowsBatch()", "フレームの add_many('stick', coords)")
+        self._legacy_frame().ArrowsBatch(segments, layer, color, size, arrowtype, _quiet=True)