graph-easy 0.0.1__py3-none-any.whl

graph_easy/__init__.py

@@ -0,0 +1,10 @@
+"""graph-easy — a Python port of Graph::Easy (GPL-2.0-or-later).
+
+Port of Graph::Easy (c) Tels, 2004-2008, <http://bloodgate.com/>.
+"""
+
+from graph_easy.parser import Edge, Graph, parse_graph
+from graph_easy.render import render
+
+__version__ = "0.0.1"
+__all__ = ["Edge", "Graph", "parse_graph", "render", "__version__"]

graph_easy/cli.py

@@ -0,0 +1,56 @@
+"""Command-line entry point — read graph DSL on stdin, print ASCII art."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from graph_easy.parser import parse_graph
+from graph_easy.render import render
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="graph-easy",
+        description="Layout and render a graph as ASCII art (Python port of Graph::Easy).",
+    )
+    ap.add_argument(
+        "file",
+        nargs="?",
+        help="read DSL from FILE instead of stdin ('-' = stdin)",
+    )
+    ap.add_argument(
+        "--ascii",
+        action="store_true",
+        help="use plain ASCII box/line characters (default: Unicode)",
+    )
+    ap.add_argument(
+        "--color",
+        action="store_true",
+        help="apply ANSI colours from fill/color attributes",
+    )
+    ap.add_argument(
+        "--no-color",
+        dest="color",
+        action="store_false",
+        help="disable ANSI colours (default when output is piped)",
+    )
+    ap.set_defaults(color=None)
+    args = ap.parse_args(argv)
+
+    if args.file and args.file != "-":
+        with open(args.file, encoding="utf-8") as fh:
+            text = fh.read()
+    else:
+        text = sys.stdin.read()
+
+    if args.color is None:
+        args.color = sys.stdout.isatty()
+    graph = parse_graph(text)
+    output = render(graph, ascii_style=args.ascii, color=args.color)
+    sys.stdout.write(output + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

graph_easy/node.py

@@ -0,0 +1,60 @@
+"""Graph::Easy node model — a labelled text box drawn in ASCII.
+
+Faithful Python port of ``Graph::Easy::Node`` dimensions/label semantics.
+A node knows its multi-line label and computes its own rendered box size;
+drawing is delegated to the renderer (``graph_easy.render``).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Node:
+    """A rectangular labelled node.
+
+    Mirrors the upstream notion that a node's box encloses a (possibly
+    multi-line) label with a one-cell padding border on every side, drawn as
+    boxes (`+---+`-style corners with `|` and `-` edges).
+
+    Columns are counted in *display cells*; a label line never shrinks the box
+    below its widest line.
+    """
+
+    label: str
+    attr_label: str | None = None
+    padding_x: int = 1
+    padding_y: int = 0
+    _width: int = 0
+    _height: int = 0
+    shape: str = "normal"
+    attrs: dict[str, str] = field(default_factory=dict)
+
+    def label_lines(self) -> list[str]:
+        """Split the label into display lines; `\\n` escapes expand to newlines."""
+        src = self.attr_label if self.attr_label is not None else self.label
+        return src.replace(r"\n", "\n").split("\n")
+
+    def inner_width(self) -> int:
+        """Width of the label area in cells (widest line, >= 1)."""
+        lines = self.label_lines()
+        if not lines:
+            return 1
+        return max(len(line) for line in lines) or 1
+
+    def inner_height(self) -> int:
+        return max(len(self.label_lines()), 1)
+
+    def width(self) -> int:
+        """Total box width = 2 borders + padding_x*2 + inner_width."""
+        return 2 + self.padding_x * 2 + self.inner_width()
+
+    def height(self) -> int:
+        """Total box height = 2 borders + padding_y*2 + inner_height."""
+        return 2 + self.padding_y * 2 + self.inner_height()
+
+    def recompute(self) -> None:
+        """Recompute cached extents after label mutation (upstream api)."""
+        self._width = self.width()
+        self._height = self.height()

graph_easy/parser.py

@@ -0,0 +1,216 @@
+"""Graph::Easy DSL parser — text graph language.
+
+Faithful translation of the upstream grammar subset::
+
+    [ node label ] --> [ other node ]
+    A -> B <- C
+    [ A ] -- label width 40 --> [ B ]
+
+Supported tokens (subset of upstream ``Parser``)::
+
+    node  := '[' label ']' | bare_word
+    edge  := '<'? connector '>'?     with connector = one+ of '-' '=' '.'
+
+    "--"    undirected            "-->"  directed to target
+    "<--"   directed from target  "<-->"  bidirectional
+
+Arbitrary repeated dashes (``--->``, ``<----`` ...) are tolerated.
+Comment lines (``# ...``) are ignored.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from graph_easy.node import Node
+
+_TOK = re.compile(
+    r"\s*"
+    r"(?:"
+    r"(\[[^\]]*\])"          # 1: bracketed node
+    r"|(<[=.\-~#]*[=.\-~#]>?)"   # 2: edge with leading '<'
+    r"|([=.\-~#]*[=.\-~#]>?)"    # 3: edge without '<'
+    r"|(\{[^{}]*\})"         # 4: attribute block { k: v; }
+    r"|([()])"               # 5: group open/close
+    r"|([^\s]+)"             # 6: bare word
+    r")"
+)
+
+
+def _parse_attrs(block: str) -> dict[str, str]:
+    """Parse ``{ key: value; key2: value2; }`` into a dict (lenient)."""
+    attrs: dict[str, str] = {}
+    for part in block.strip("{}").split(";"):
+        if ":" not in part:
+            continue
+        k, _, v = part.partition(":")
+        k = k.strip()
+        v = v.strip()
+        if k:
+            attrs[k] = v
+    return attrs
+
+
+@dataclass
+class Edge:
+    """Directed/undirected connection between two nodes."""
+
+    source: str
+    target: str
+    label: str | None = None
+    directed_to_target: bool = True  # arrow at the target ('-->')
+    directed_from_source: bool = False  # arrow at the source ('<--')
+    style: str | None = None
+    attrs: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class Graph:
+    """Parsed in-memory graph."""
+
+    nodes: dict[str, Node] = field(default_factory=dict)
+    edges: list[Edge] = field(default_factory=list)
+    link_labels: list[str] = field(default_factory=list)
+
+    def add_node(self, label: str) -> Node:
+        if label not in self.nodes:
+            self.nodes[label] = Node(label=label)
+        return self.nodes[label]
+
+
+_LABELLED_EDGE = re.compile(
+    r"\s*(?P<style1>[-=.]+)\s+(?P<label>[^{<>\s][^<>\n]*?)\s+"
+    r"(?P<style2>[-=.]+)(?P<after>>)?"
+)
+
+
+def _tokens(line: str) -> list[tuple[str, str]]:
+    """Tokenise one line into (kind, value) pairs: ('node'|'edge', text).
+
+    An edge written ``-- label -->`` yields an ``edge`` token immediately
+    followed by a ``label`` token; ``_stitch`` attaches the label to the edge.
+    """
+    out: list[tuple[str, str]] = []
+    pos = 0
+    while pos < len(line):
+        m = _TOK.match(line, pos)
+        if not m:
+            pos += 1
+            continue
+        pos = m.end()
+        if m.group(2) is not None or m.group(3) is not None:
+            op = m.group(2) or m.group(3)
+            le = _LABELLED_EDGE.match(line, m.start())
+            if le:
+                out.append(("edge", op))
+                out.append(("label", le.group("label")))
+                pos = le.end()
+            else:
+                out.append(("edge", op))
+        elif m.group(1) is not None:
+            out.append(("node", m.group(1)[1:-1].strip()))
+        elif m.group(4) is not None:
+            out.append(("attr", m.group(4)))
+        elif m.group(5) is not None:
+            if m.group(5) == "(":
+                out.append(("group_open", ""))
+            else:
+                out.append(("group_close", ""))
+        else:
+            out.append(("node", m.group(6)))
+    return out
+
+
+def _edge_style(op: str) -> str | None:
+    """Map a connector string to a style name (upstream Parser::_edge_style)."""
+    if re.fullmatch(r"=+", op):
+        return "double"
+    if re.fullmatch(r"\.+", op):
+        return "dotted"
+    if re.fullmatch(r"~+", op):
+        return "wave"
+    if re.fullmatch(r"#+", op):
+        return "bold"
+    if re.fullmatch(r"(\.-)+", op):
+        return "dot-dash"
+    if re.fullmatch(r"(\.\.-)+", op):
+        return "dot-dot-dash"
+    return None
+
+
+def _stitch(g: Graph, tokens: list[tuple[str, str]]) -> None:
+    """Turn a token stream (node edge node edge ...) into edges on ``g``.
+
+    Attribute blocks ``{ k: v; }`` attach to the most recent object: the
+    pending edge when one is open (``-- { a } -->``), else the last node.
+    """
+    prev: str | None = None
+    pending_op: str | None = None
+    pending_label: str | None = None
+    pending_attrs: dict[str, str] = {}
+    group_name: str | None = None
+    expect_group_name = False
+    i = 0
+    while i < len(tokens):
+        kind, value = tokens[i]
+        if kind == "group_open":
+            expect_group_name = True
+            i += 1
+            continue
+        if kind == "group_close":
+            group_name = None
+            expect_group_name = False
+            i += 1
+            continue
+        if kind == "label":
+            pending_label = value
+            i += 1
+            continue
+        if kind == "edge":
+            pending_op = value
+            i += 1
+            continue
+        if kind == "attr":
+            if pending_op is None:
+                if prev is not None:
+                    g.nodes[prev].attrs.update(_parse_attrs(value))
+            else:
+                pending_attrs.update(_parse_attrs(value))
+            i += 1
+            continue
+        if expect_group_name and group_name is None:
+            group_name = value
+            expect_group_name = False
+            i += 1
+            continue
+        g.add_node(value)
+        if group_name is not None:
+            g.nodes[value].attrs["group"] = group_name
+        if pending_op is not None and prev is not None:
+            e = Edge(source=prev, target=value)
+            e.directed_to_target = pending_op.endswith(">")
+            e.directed_from_source = pending_op.startswith("<")
+            e.label = pending_label
+            e.style = _edge_style(pending_op.strip("<>"))
+            e.attrs = dict(pending_attrs)
+            g.edges.append(e)
+        elif pending_attrs:
+            g.nodes[value].attrs.update(pending_attrs)
+        pending_op = None
+        pending_label = None
+        pending_attrs = {}
+        prev = value
+        i += 1
+
+
+def parse_graph(text: str, *, link_as_default_label: bool = False) -> Graph:
+    """Parse graph DSL text into a :class:`Graph`."""
+
+    g = Graph()
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+        _stitch(g, _tokens(line))
+    return g

graph_easy/render.py

@@ -0,0 +1,377 @@
+"""ASCII renderer — draw parsed graphs as terminal box-and-wire diagrams.
+
+Port of the visual semantics of ``Graph::Easy::As_ascii`` for the supported
+subset, laid out on a character canvas:
+
+* nodes are boxed and grouped into horizontal layers (longest-path layering)
+* within a layer, nodes stack vertically
+* edges connect layers with arrows; the connector style selects the line
+  characters (``--`` solid, ``..`` dotted, ``==`` double, ``~~`` wave,
+  ``##`` bold); vertical runs and arrowheads follow the same style.
+
+Independent components render as separate stacked diagrams.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+
+from graph_easy.node import Node
+from graph_easy.parser import Edge, Graph
+
+_CHANNEL = 9
+
+_BoxChars = tuple[str, str, str, str, str, str]  # tl, tr, bl, br, v, h
+
+_BOX_UNICODE: _BoxChars = ("┌", "┐", "└", "┘", "│", "─")
+_BOX_ASCII: _BoxChars = ("+", "+", "+", "+", "|", "-")
+
+_STYLE_UNICODE: dict[str, tuple[str, str, str]] = {
+    "solid": ("─", "│", "┼"),
+    "double": ("═", "║", "╬"),
+    "dotted": ("·", ":", "┼"),
+    "dashed": ("╴", "╵", "┼"),
+    "wave": ("∼", "≀", "┼"),
+    "bold": ("━", "┃", "╋"),
+    "dot-dash": ("·", "!", "┼"),
+    "dot-dot-dash": ("·", "!", "┼"),
+}
+_STYLE_ASCII: dict[str, tuple[str, str, str]] = {
+    "solid": ("-", "|", "+"),
+    "double": ("=", '"', "#"),
+    "dotted": (".", ":", "+"),
+    "dashed": ("-", "'", "+"),
+    "wave": ("~", "~", "~"),
+    "bold": ("#", "#", "#"),
+    "dot-dash": (".", ":", "+"),
+    "dot-dot-dash": (".", ":", "+"),
+}
+_STYLE_DEFAULT = "solid"
+
+# ANSI colour table — the 16 standard terminal colours plus common names.
+_ANSI_FG: dict[str, str] = {
+    "black": "30", "red": "31", "green": "32", "yellow": "33",
+    "blue": "34", "magenta": "35", "cyan": "36", "white": "37",
+    "brightred": "91", "brightgreen": "92", "brightyellow": "93",
+    "brightblue": "94", "brightmagenta": "95", "brightcyan": "96",
+    "grey": "90", "gray": "90", "brightwhite": "97",
+}
+_ANSI_BG: dict[str, str] = {
+    "black": "40", "red": "41", "green": "42", "yellow": "43",
+    "blue": "44", "magenta": "45", "cyan": "46", "white": "47",
+    "brightred": "101", "brightgreen": "102", "brightyellow": "103",
+    "brightblue": "104", "brightmagenta": "105", "brightcyan": "106",
+    "grey": "100", "gray": "100", "brightwhite": "107",
+}
+
+
+def _ansi_fg(name: str) -> str:
+    return _ANSI_FG.get(name.strip().lower(), "")
+
+
+def _ansi_bg(name: str) -> str:
+    return _ANSI_BG.get(name.strip().lower(), "")
+
+
+def _apply_color(canvas: list[list[str]], pos: dict, graph: Graph) -> None:
+    """Post-process: wrap each node's interior rows in ANSI colour codes."""
+    for name, (x0, y0, w, h) in pos.items():
+        node = graph.nodes[name]
+        fg = _ansi_fg(node.attrs.get("color", ""))
+        bg = _ansi_bg(node.attrs.get("fill", ""))
+        codes = [c for c in (bg, fg) if c]
+        if not codes:
+            continue
+        start = "\x1b[" + ";".join(codes) + "m"
+        end = "\x1b[0m"
+        for r in range(1, h - 1):
+            row = canvas[y0 + r]
+            row[x0] = start + row[x0]
+            row[x0 + w - 1] += end
+
+
+def _box(node: Node, box: _BoxChars) -> list[str]:
+    """Render one node as a list of text rows (top border .. bottom border).
+
+    Shape/attribute aware: ``shape: diamond`` draws a rhombus, ``border:
+    double/dashed`` changes the frame characters.
+    """
+    tl, tr, bl, br, v, h = box
+    shape = node.attrs.get("shape", "normal")
+    border = node.attrs.get("border", "solid")
+    if shape == "diamond":
+        return _box_diamond(node, border, box)
+    pad_x = node.padding_x
+    pad_y = node.padding_y
+    inner_w = node.inner_width()
+    lines = node.label_lines()
+    w = node.width()
+    hgt = node.height()
+    if border == "double":
+        h2, v2 = "═", "║"
+    elif border == "dashed":
+        h2, v2 = "╌", "╎"
+    else:
+        h2, v2 = h, v
+    if shape in ("ellipse", "rounded"):
+        tl, tr, bl, br = "╭", "╮", "╰", "╯"
+    border_t = tl + h2 * (w - 2) + tr
+    rows: list[str] = [border_t]
+    for _ in range(pad_y):
+        rows.append(v2 + " " * (w - 2) + v2)
+    for line in lines:
+        right = max(inner_w - len(line), 0)
+        rows.append(v2 + " " * pad_x + line + " " * (pad_x + right) + v2)
+    for _ in range(pad_y):
+        rows.append(v2 + " " * (w - 2) + v2)
+    rows.append(bl + h2 * (w - 2) + br)
+    return rows
+
+
+def _box_diamond(node: Node, border: str, box: _BoxChars) -> list[str]:
+    """Diamond (rhombus) node — label centered on the widest diagonal row."""
+    _, _, _, _, v, h = box
+    hch = "═" if border == "double" else h
+    vch = "║" if border == "double" else v
+    lines = node.label_lines()
+    inner_w = node.inner_width()
+    half = inner_w // 2
+    width = inner_w + 4
+    total_rows = len(lines) + 2
+    rows: list[str] = []
+    for r in range(total_rows):
+        if r == 0:
+            row = " " * (half + 1) + "/" + hch * max(inner_w - 2, 1) + "\\"
+        elif r == total_rows - 1:
+            row = " " * (half + 1) + "\\" + hch * max(inner_w - 2, 1) + "/"
+        else:
+            li = r - 1
+            pad = abs(half - li)
+            text = lines[li] if li < len(lines) else ""
+            left_pad = " " * (pad + 1)
+            right_pad = " " * (max(inner_w - len(text), 0) + pad + 1)
+            row = left_pad + vch + text + right_pad + vch
+        rows.append(row.ljust(width))
+    return rows
+
+
+def _components(graph: Graph) -> list[list[str]]:
+    """Split nodes into connected components (preserving insertion order)."""
+    adj: dict[str, set[str]] = {n: set() for n in graph.nodes}
+    for e in graph.edges:
+        if e.source in adj and e.target in adj:
+            adj[e.source].add(e.target)
+            adj[e.target].add(e.source)
+    seen: set[str] = set()
+    comps: list[list[str]] = []
+    for start in graph.nodes:
+        if start in seen:
+            continue
+        q: deque[str] = deque([start])
+        cur: set[str] = set()
+        while q:
+            u = q.popleft()
+            if u in seen:
+                continue
+            seen.add(u)
+            cur.add(u)
+            for v in adj[u]:
+                if v not in seen:
+                    q.append(v)
+        comps.append([n for n in graph.nodes if n in cur])
+    return comps
+
+
+def _layers(comp: list[str], graph: Graph) -> list[list[str]]:
+    """Longest-path layering: rank[v] = 1 + max(rank[u]) over edges u->v."""
+    rank = {n: 0 for n in comp}
+    for _ in range(len(comp)):  # longest path needs at most len-1 passes
+        changed = False
+        for e in graph.edges:
+            if e.source in rank and e.target in rank and rank[e.target] <= rank[e.source]:
+                rank[e.target] = rank[e.source] + 1
+                changed = True
+        if not changed:
+            break
+    by_rank: dict[int, list[str]] = {}
+    for n in comp:
+        by_rank.setdefault(rank[n], []).append(n)
+    return [by_rank[r] for r in sorted(by_rank)]
+
+
+def _draw_edge(
+    canvas: list[list[str]],
+    pos: dict[str, tuple[int, int, int, int]],
+    edge: Edge,
+    styles: dict[str, tuple[str, str, str]],
+    *,
+    vertical_only: bool = False,
+) -> None:
+    sx0, sy0, sw, sh = pos[edge.source]
+    tx0, ty0, tw, th = pos[edge.target]
+    sx = sx0 + sw
+    tx = tx0
+    sy = sy0 + sh // 2
+    ty = ty0 + th // 2
+    cx = sx + _CHANNEL // 2
+
+    hch, vch, cch = styles.get(edge.style or _STYLE_DEFAULT)
+
+    arrowshape = edge.attrs.get("arrowshape", "")
+    if styles is _STYLE_ASCII:
+        ar, al = ">", "<"
+    elif arrowshape == "filled":
+        ar, al = "▶", "◀"
+    else:
+        ar, al = ">", "<"
+
+    def put(x: int, y: int, ch: str) -> None:
+        if 0 <= y < len(canvas) and 0 <= x < len(canvas[y]):
+            canvas[y][x] = ch
+
+    def put_cross(x: int, y: int, ch: str) -> None:
+        if 0 <= y < len(canvas) and 0 <= x < len(canvas[y]):
+            if canvas[y][x] == " ":
+                canvas[y][x] = ch
+            elif canvas[y][x] != ch:
+                canvas[y][x] = cch
+
+    if sy == ty:
+        if vertical_only:
+            return
+        if edge.label:
+            left = f"{hch}{hch}" if not edge.directed_from_source else f"{al}{hch}{hch}"
+            right = f"{hch}{hch}{ar}" if edge.directed_to_target else f"{hch}{hch}"
+            arrow = f"{left} {edge.label} {right}"
+        else:
+            arrow = f"{hch}{hch}{ar}" if edge.directed_to_target else f"{hch}{hch}"
+            if edge.directed_from_source:
+                arrow = al + arrow
+        start = sx + 1
+        end = tx - 1
+        width = end - start + 1
+        if width > len(arrow):
+            cells = [hch] * width
+            if arrow.startswith(al):
+                cells[0] = al
+            if arrow.endswith(ar):
+                cells[-1] = ar
+            for i, ch in enumerate(cells):
+                put(start + i, sy, ch)
+        else:
+            for i, ch in enumerate(arrow):
+                put(start + i, sy, ch)
+        return
+
+    # route the vertical arm from the source's bottom edge so it never
+    # collides with horizontal arrows leaving the source's mid row
+    sy = sy0 + sh - 1
+    lo, hi = (sy, ty) if sy < ty else (ty, sy)
+    if vertical_only:
+        for y in range(lo + 1, hi):
+            put_cross(cx, y, vch)
+        return
+
+    for x in range(sx + 1, cx):
+        put(x, sy, hch)
+    for x in range(cx, tx):
+        put(x, ty, hch)
+    if edge.directed_to_target:
+        put(tx - 1, ty, ar)
+    if edge.directed_from_source:
+        put(sx + 1, sy, al)
+    if edge.label:
+        mid_y = (lo + hi) // 2
+        for i, ch in enumerate(edge.label):
+            put(cx + i + 1, mid_y, ch)
+
+
+def render(graph: Graph, *, ascii_style: bool = False, color: bool = False) -> str:
+    """Render the graph to multi-line ASCII/Unicode text (no trailing newline)."""
+    if not graph.nodes:
+        return ""
+    box_chars = _BOX_ASCII if ascii_style else _BOX_UNICODE
+    styles = _STYLE_ASCII if ascii_style else _STYLE_UNICODE
+    bands: list[str] = []
+    for comp in _components(graph):
+        layers = _layers(comp, graph)
+        layer_boxes = [[_box(graph.nodes[n], box_chars) for n in layer] for layer in layers]
+        col_w = [max(max(len(row) for row in b) for b in boxes) for boxes in layer_boxes]
+        col_h = [sum(len(b) for b in boxes) + (len(boxes) - 1) for boxes in layer_boxes]
+        y_offs: list[list[int]] = []
+        for boxes in layer_boxes:
+            offs: list[int] = []
+            y = 0
+            for b in boxes:
+                offs.append(y)
+                y += len(b) + 1
+            y_offs.append(offs)
+
+        has_groups = any(graph.nodes[n].attrs.get("group") for n in comp)
+        pad = 1 if has_groups else 0
+        height = (max(col_h) if col_h else 0) + 2 * pad
+        width = (sum(col_w) + _CHANNEL * (len(layers) - 1)) + 2 * pad
+        canvas = [[" "] * width for _ in range(height)]
+        pos: dict[str, tuple[int, int, int, int]] = {}
+        x = pad
+        for c, boxes in enumerate(layer_boxes):
+            for i, b in enumerate(boxes):
+                x0 = x
+                y0 = y_offs[c][i] + pad
+                for r, row in enumerate(b):
+                    for cc, ch in enumerate(row):
+                        canvas[y0 + r][x0 + cc] = ch
+                pos[layers[c][i]] = (x0, y0, len(b[0]), len(b))
+            x += col_w[c] + _CHANNEL
+
+        edges_in_comp = [e for e in graph.edges if e.source in pos and e.target in pos]
+        for e in edges_in_comp:
+            _draw_edge(canvas, pos, e, styles, vertical_only=True)
+        for e in edges_in_comp:
+            _draw_edge(canvas, pos, e, styles)
+        _draw_groups(canvas, pos, graph, box_chars)
+        if color:
+            _apply_color(canvas, pos, graph)
+        bands.append("\n".join("".join(row).rstrip() for row in canvas))
+    return "\n\n".join(bands)
+
+
+def _draw_groups(
+    canvas: list[list[str]],
+    pos: dict[str, tuple[int, int, int, int]],
+    graph: Graph,
+    box: _BoxChars,
+) -> None:
+    """Draw a labelled dashed frame around each group's nodes."""
+    by_group: dict[str, list[str]] = {}
+    for n in graph.nodes:
+        grp = graph.nodes[n].attrs.get("group")
+        if grp and n in pos:
+            by_group.setdefault(grp, []).append(n)
+    for grp, members in by_group.items():
+        xs = [pos[m][0] for m in members]
+        ys = [pos[m][1] for m in members]
+        xe = [pos[m][0] + pos[m][2] for m in members]
+        ye = [pos[m][1] + pos[m][3] for m in members]
+        x0, x1 = min(xs) - 1, max(xe) + 1
+        y0, y1 = min(ys) - 1, max(ye) + 1
+        x0 = max(x0, 0)
+        y0 = max(y0, 0)
+        x1 = min(x1, len(canvas[0]) - 1)
+        y1 = min(y1, len(canvas) - 1)
+        for x in range(x0, x1 + 1):
+            if canvas[y0][x] == " ":
+                canvas[y0][x] = "─"
+            if canvas[y1][x] == " ":
+                canvas[y1][x] = "─"
+        for y in range(y0, y1 + 1):
+            if canvas[y][x0] == " ":
+                canvas[y][x0] = "│"
+            if canvas[y][x1] == " ":
+                canvas[y][x1] = "│"
+        canvas[y0][x0], canvas[y0][x1] = "┌", "┐"
+        canvas[y1][x0], canvas[y1][x1] = "└", "┘"
+        label = f" {grp} "
+        for i, ch in enumerate(label):
+            if x0 + 1 + i <= x1:
+                canvas[y0][x0 + 1 + i] = ch

graph_easy-0.0.1.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: graph-easy
+Version: 0.0.1
+Summary: A Python port of Graph::Easy - lay out and render graphs as ASCII art
+Author: Tels (original Graph::Easy author)
+License: GPL-2.0-or-later
+Project-URL: Original, https://github.com/ironcamel/Graph-Easy
+Keywords: graph,ascii,diagram,layout,graphviz
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# graph-easy
+
+A **Python port** of [Graph::Easy](https://github.com/ironcamel/Graph-Easy),
+the Perl tool that lays out directed/undirected graphs and renders them as
+**ASCII art** (box-and-wire diagrams rendered in the terminal).
+
+This project faithfully translates the original Perl implementation to Python,
+in order to provide the same functionality to Python users / as a native Python
+library and command-line tool.
+
+## Provenance & License
+
+- Original: **Graph::Easy**, Copyright (C) 2004 - 2008 by **Tels**
+  (<http://bloodgate.com/>).
+- Upstream repository: <https://github.com/ironcamel/Graph-Easy>
+- This port is licensed under the **GNU General Public License, version 2 or
+  (at your option) any later version** — the same license as the original
+  Graph::Easy, because a port is a derivative work.
+
+See [`LICENSE`](./LICENSE) for the full LGPL/ GPL text.
+
+### Third-party color schemes
+
+This product includes color specifications and designs developed by Cynthia
+Brewer (<http://colorbrewer.org/>), used under the
+Apache-Style Software License for ColorBrewer Color Schemes v1.1,
+© 2002 Cynthia Brewer, Mark Harrower, and The Pennsylvania State University.
+See the header of the original `Graph::Easy::Attributes` for the full notice.
+
+## Status
+
+Actively-developed port. Currently implemented:
+
+- **DSL parser**: `[ label ]`/bare nodes, `-->` `<--` `<-->` `--` arrows,
+  labelled edges (`-- label -->`), multiline labels (`\n`), comments
+- **Layout engine**: longest-path layering with orthogonal edge routing —
+  chains, branches, merges and cycles all render correctly; independent
+  components stack as separate diagrams
+- **Edge line styles** (faithful to upstream `Parser::_edge_style`):
+  `--` solid, `..` dotted, `==` double, `~~` wave, `##` bold, `.-`/`..-` dot-dash
+- **Two output charsets**: Unicode box-drawing by default
+  (`┌──┐ ──> ══ ║ ·`), plain ASCII via `--ascii`
+
+The heavier automatic layout engine (`Graph::Easy::Layout` grid solver) is a
+follow-up milestone.
+
+## Usage
+
+```console
+$ printf '[ Bonn ] --> [ Berlin ] --> [ Hamburg ]\n' | graph-easy
+┌──────┐         ┌────────┐         ┌─────────┐
+│ Bonn │ ───────>│ Berlin │ ───────>│ Hamburg │
+└──────┘         └────────┘         └─────────┘
+
+# plain-ASCII output
+$ printf '[ A ] ..> [ B ]\n' | graph-easy --ascii
++---+         +---+
+| A | .......>| B |
++---+         +---+
+```
+
+## Development
+
+```console
+$ python -m venv .venv && source .venv/bin/activate
+$ pip install -e '.[dev]'
+$ pytest
+```
+
+## Acknowledgments
+
+Thanks to Tels and the Graph::Easy contributors whose careful layout and
+rendering work this port builds upon.

graph_easy-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+graph_easy/__init__.py,sha256=_2HIh7t702j2VtarERwXRSwcPzMagOUIla7rk53OcT0,322
+graph_easy/cli.py,sha256=16wDAKmti9l-JHYIWhUokHkwentfY2XGn_u9J6gzNdc,1513
+graph_easy/node.py,sha256=nNJk61lnE7d78SrsHN6dV09knOa55PQ32vMN5BN788g,2036
+graph_easy/parser.py,sha256=0_u3PAzyqlzPtBziGffVcKrk36DCjhMkVVbq5ALr52c,6635
+graph_easy/render.py,sha256=Iy-GsBTJ4PtnqYT9WFhzAQd2UIV-_RJqQuAWAjggQCY,13389
+graph_easy-0.0.1.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+graph_easy-0.0.1.dist-info/METADATA,sha256=KZonBLwebMeWHJxWJMIAv4_D_R0uoDDkj4koEimLlA4,3485
+graph_easy-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+graph_easy-0.0.1.dist-info/entry_points.txt,sha256=to15qxIiDoLms8qVBiEWYlFWUG0NJfqF4hM_tiqcMrw,51
+graph_easy-0.0.1.dist-info/top_level.txt,sha256=PXdbO_ZlPTqVIP2paMrLxul2u1Zito6rRCDkAKKmRNY,11
+graph_easy-0.0.1.dist-info/RECORD,,

graph_easy-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

graph_easy-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+graph-easy = graph_easy.cli:main

graph_easy-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,338 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Moe Ghoul>, 1 April 1989
+  Moe Ghoul, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

graph_easy-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+graph_easy