renderdag 0.1.0__py3-none-any.whl

renderdag/__init__.py

@@ -0,0 +1,25 @@
+from ._render import (
+    Ancestor,
+    AncestorType,
+    GraphRow,
+    GraphRowRenderer,
+    LinkLine,
+    NodeLine,
+    PadLine,
+)
+from ._ascii import AsciiRenderer
+from ._ascii_large import AsciiLargeRenderer
+from ._box_drawing import BoxDrawingRenderer
+
+__all__ = [
+    "Ancestor",
+    "AncestorType",
+    "GraphRow",
+    "GraphRowRenderer",
+    "LinkLine",
+    "NodeLine",
+    "PadLine",
+    "AsciiRenderer",
+    "AsciiLargeRenderer",
+    "BoxDrawingRenderer",
+]

renderdag/_ascii.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from ._output import OutputRendererOptions
+from ._pad import pad_lines
+from ._render import (
+    AncestorType,
+    GraphRow,
+    GraphRowRenderer,
+    LinkLine,
+    NodeLine,
+    PadLine,
+)
+
+
+class AsciiRenderer:
+    def __init__(self, inner: GraphRowRenderer, options: OutputRendererOptions) -> None:
+        self._inner = inner
+        self._options = options
+        self._extra_pad_line: str | None = None
+
+    def width(
+        self,
+        node: object | None = None,
+        parents: list[AncestorType] | None = None,
+    ) -> int:
+        return self._inner.width(node, parents) * 2 + 1
+
+    def reserve(self, node: object) -> None:
+        self._inner.reserve(node)
+
+    def next_row(
+        self,
+        node: object,
+        parents: list[AncestorType],
+        glyph: str,
+        message: str,
+    ) -> str:
+        line = self._inner.next_row(node, parents, glyph, message)
+        out: list[str] = []
+        message_lines = pad_lines(
+            line.message.splitlines(), self._options.min_row_height
+        )
+        message_iter = iter(message_lines)
+        need_extra_pad_line = False
+
+        if self._extra_pad_line is not None:
+            out.append(self._extra_pad_line.rstrip())
+            out.append("\n")
+            self._extra_pad_line = None
+
+        # Node line
+        node_line_str = ""
+        for entry in line.node_line:
+            if entry == NodeLine.NODE:
+                node_line_str += line.glyph + " "
+            elif entry == NodeLine.PARENT:
+                node_line_str += "| "
+            elif entry == NodeLine.ANCESTOR:
+                node_line_str += ". "
+            else:
+                node_line_str += "  "
+        msg = next(message_iter, None)
+        if msg is not None:
+            node_line_str += " " + msg
+        out.append(node_line_str.rstrip())
+        out.append("\n")
+
+        # Link line
+        if line.link_line is not None:
+            link_row = line.link_line
+            any_horizontal = any(
+                cur.intersects(LinkLine.HORIZONTAL) for cur in link_row
+            )
+            link_line_str = ""
+            extended = list(link_row) + [LinkLine(0)]
+            for idx in range(len(link_row)):
+                cur = extended[idx]
+                nxt = extended[idx + 1]
+
+                # Column character
+                if cur.intersects(LinkLine.HORIZONTAL):
+                    if cur.intersects(LinkLine.CHILD | LinkLine.ANY_FORK_OR_MERGE):
+                        link_line_str += "+"
+                    else:
+                        link_line_str += "-"
+                elif cur.intersects(LinkLine.VERTICAL):
+                    if cur.intersects(LinkLine.ANY_FORK_OR_MERGE) and any_horizontal:
+                        link_line_str += "+"
+                    elif cur.intersects(LinkLine.VERT_PARENT):
+                        link_line_str += "|"
+                    else:
+                        link_line_str += "."
+                elif cur.intersects(LinkLine.ANY_MERGE) and any_horizontal:
+                    link_line_str += "'"
+                elif cur.intersects(LinkLine.ANY_FORK) and any_horizontal:
+                    link_line_str += "."
+                else:
+                    link_line_str += " "
+
+                # Connecting character
+                if cur.intersects(LinkLine.HORIZONTAL):
+                    link_line_str += "-"
+                elif cur.intersects(LinkLine.RIGHT_MERGE):
+                    if nxt.intersects(LinkLine.LEFT_FORK) and not any_horizontal:
+                        link_line_str += "\\"
+                    else:
+                        link_line_str += "-"
+                elif cur.intersects(LinkLine.RIGHT_FORK):
+                    if nxt.intersects(LinkLine.LEFT_MERGE) and not any_horizontal:
+                        link_line_str += "/"
+                    else:
+                        link_line_str += "-"
+                else:
+                    link_line_str += " "
+
+            msg = next(message_iter, None)
+            if msg is not None:
+                link_line_str += " " + msg
+            out.append(link_line_str.rstrip())
+            out.append("\n")
+
+        # Term line
+        if line.term_line is not None:
+            term_row = line.term_line
+            term_strs = ["| ", "~ "]
+            for term_str in term_strs:
+                term_line_str = ""
+                for i, term in enumerate(term_row):
+                    if term:
+                        term_line_str += term_str
+                    else:
+                        if line.pad_lines[i] == PadLine.PARENT:
+                            term_line_str += "| "
+                        elif line.pad_lines[i] == PadLine.ANCESTOR:
+                            term_line_str += ". "
+                        else:
+                            term_line_str += "  "
+                msg = next(message_iter, None)
+                if msg is not None:
+                    term_line_str += " " + msg
+                out.append(term_line_str.rstrip())
+                out.append("\n")
+            need_extra_pad_line = True
+
+        # Base pad line
+        base_pad_line = ""
+        for entry in line.pad_lines:
+            if entry == PadLine.PARENT:
+                base_pad_line += "| "
+            elif entry == PadLine.ANCESTOR:
+                base_pad_line += ". "
+            else:
+                base_pad_line += "  "
+
+        # Remaining message lines
+        for msg in message_iter:
+            pad_line = base_pad_line + " " + msg
+            out.append(pad_line.rstrip())
+            out.append("\n")
+            need_extra_pad_line = False
+
+        if need_extra_pad_line:
+            self._extra_pad_line = base_pad_line
+
+        return "".join(out)

renderdag/_ascii_large.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from ._output import OutputRendererOptions
+from ._pad import pad_lines
+from ._render import (
+    AncestorType,
+    GraphRow,
+    GraphRowRenderer,
+    LinkLine,
+    NodeLine,
+    PadLine,
+)
+
+
+class AsciiLargeRenderer:
+    def __init__(self, inner: GraphRowRenderer, options: OutputRendererOptions) -> None:
+        self._inner = inner
+        self._options = options
+        self._extra_pad_line: str | None = None
+
+    def width(
+        self,
+        node: object | None = None,
+        parents: list[AncestorType] | None = None,
+    ) -> int:
+        return self._inner.width(node, parents) * 3 - 1 + 1
+
+    def reserve(self, node: object) -> None:
+        self._inner.reserve(node)
+
+    def next_row(
+        self,
+        node: object,
+        parents: list[AncestorType],
+        glyph: str,
+        message: str,
+    ) -> str:
+        line = self._inner.next_row(node, parents, glyph, message)
+        out: list[str] = []
+        message_lines = pad_lines(
+            line.message.splitlines(), self._options.min_row_height
+        )
+        message_iter = iter(message_lines)
+        need_extra_pad_line = False
+
+        if self._extra_pad_line is not None:
+            out.append(self._extra_pad_line.rstrip())
+            out.append("\n")
+            self._extra_pad_line = None
+
+        # Node line
+        node_line_str = ""
+        for i, entry in enumerate(line.node_line):
+            if entry == NodeLine.NODE:
+                if i > 0:
+                    node_line_str += " "
+                node_line_str += line.glyph + " "
+            elif entry == NodeLine.PARENT:
+                node_line_str += " | " if i > 0 else "| "
+            elif entry == NodeLine.ANCESTOR:
+                node_line_str += " . " if i > 0 else ". "
+            else:
+                node_line_str += "   " if i > 0 else "  "
+        msg = next(message_iter, None)
+        if msg is not None:
+            node_line_str += " " + msg
+        out.append(node_line_str.rstrip())
+        out.append("\n")
+
+        # Link line
+        if line.link_line is not None:
+            link_row = line.link_line
+            top_link = ""
+            bot_link = ""
+            for i, cur in enumerate(link_row):
+                # Top left
+                if i > 0:
+                    if cur.intersects(LinkLine.LEFT_MERGE_PARENT):
+                        top_link += "/"
+                    elif cur.intersects(LinkLine.LEFT_MERGE_ANCESTOR):
+                        top_link += "."
+                    elif cur.intersects(LinkLine.HORIZ_PARENT):
+                        top_link += "_"
+                    elif cur.intersects(LinkLine.HORIZ_ANCESTOR):
+                        top_link += "."
+                    else:
+                        top_link += " "
+
+                # Top center
+                if cur.intersects(LinkLine.VERT_PARENT):
+                    top_link += "|"
+                elif cur.intersects(LinkLine.VERT_ANCESTOR):
+                    top_link += "."
+                elif cur.intersects(LinkLine.ANY_MERGE):
+                    top_link += " "
+                elif cur.intersects(LinkLine.HORIZ_PARENT):
+                    top_link += "_"
+                elif cur.intersects(LinkLine.HORIZ_ANCESTOR):
+                    top_link += "."
+                else:
+                    top_link += " "
+
+                # Top right
+                if cur.intersects(LinkLine.RIGHT_MERGE_PARENT):
+                    top_link += "\\"
+                elif cur.intersects(LinkLine.RIGHT_MERGE_ANCESTOR):
+                    top_link += "."
+                elif cur.intersects(LinkLine.HORIZ_PARENT):
+                    top_link += "_"
+                elif cur.intersects(LinkLine.HORIZ_ANCESTOR):
+                    top_link += "."
+                else:
+                    top_link += " "
+
+                # Bottom left
+                if i > 0:
+                    if cur.intersects(LinkLine.LEFT_FORK_PARENT):
+                        bot_link += "\\"
+                    elif cur.intersects(LinkLine.LEFT_FORK_ANCESTOR):
+                        bot_link += "."
+                    else:
+                        bot_link += " "
+
+                # Bottom center
+                if cur.intersects(LinkLine.VERT_PARENT):
+                    bot_link += "|"
+                elif cur.intersects(LinkLine.VERT_ANCESTOR):
+                    bot_link += "."
+                else:
+                    bot_link += " "
+
+                # Bottom right
+                if cur.intersects(LinkLine.RIGHT_FORK_PARENT):
+                    bot_link += "/"
+                elif cur.intersects(LinkLine.RIGHT_FORK_ANCESTOR):
+                    bot_link += "."
+                else:
+                    bot_link += " "
+
+            msg = next(message_iter, None)
+            if msg is not None:
+                top_link += " " + msg
+            msg = next(message_iter, None)
+            if msg is not None:
+                bot_link += " " + msg
+            out.append(top_link.rstrip())
+            out.append("\n")
+            out.append(bot_link.rstrip())
+            out.append("\n")
+
+        # Term line
+        if line.term_line is not None:
+            term_row = line.term_line
+            term_strs = ["| ", "~ "]
+            for term_str in term_strs:
+                term_line_str = ""
+                for i, term in enumerate(term_row):
+                    if i > 0:
+                        term_line_str += " "
+                    if term:
+                        term_line_str += term_str
+                    else:
+                        if line.pad_lines[i] == PadLine.PARENT:
+                            term_line_str += "| "
+                        elif line.pad_lines[i] == PadLine.ANCESTOR:
+                            term_line_str += ". "
+                        else:
+                            term_line_str += "  "
+                msg = next(message_iter, None)
+                if msg is not None:
+                    term_line_str += " " + msg
+                out.append(term_line_str.rstrip())
+                out.append("\n")
+            need_extra_pad_line = True
+
+        # Base pad line
+        base_pad_line = ""
+        for i, entry in enumerate(line.pad_lines):
+            if entry == PadLine.PARENT:
+                base_pad_line += " | " if i > 0 else "| "
+            elif entry == PadLine.ANCESTOR:
+                base_pad_line += " . " if i > 0 else ". "
+            else:
+                base_pad_line += "   " if i > 0 else "  "
+
+        # Remaining message lines
+        for msg in message_iter:
+            pad_line = base_pad_line + " " + msg
+            out.append(pad_line.rstrip())
+            out.append("\n")
+            need_extra_pad_line = False
+
+        if need_extra_pad_line:
+            self._extra_pad_line = base_pad_line
+
+        return "".join(out)

renderdag/_box_drawing.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+from ._output import OutputRendererOptions
+from ._pad import pad_lines
+from ._render import (
+    AncestorType,
+    GraphRow,
+    GraphRowRenderer,
+    LinkLine,
+    NodeLine,
+    PadLine,
+)
+
+SPACE = 0
+HORIZONTAL = 1
+PARENT = 2
+ANCESTOR = 3
+MERGE_LEFT = 4
+MERGE_RIGHT = 5
+MERGE_BOTH = 6
+FORK_LEFT = 7
+FORK_RIGHT = 8
+FORK_BOTH = 9
+JOIN_LEFT = 10
+JOIN_RIGHT = 11
+JOIN_BOTH = 12
+TERMINATION = 13
+
+SQUARE_GLYPHS = [
+    "  ", "──", "│ ", "· ", "┘ ", "└─", "┴─", "┐ ", "┌─", "┬─", "┤ ", "├─", "┼─", "~ ",
+]
+
+CURVED_GLYPHS = [
+    "  ", "──", "│ ", "╷ ", "╯ ", "╰─", "┴─", "╮ ", "╭─", "┬─", "┤ ", "├─", "┼─", "~ ",
+]
+
+DEC_GLYPHS = [
+    "  ",
+    "\x1b(0qq\x1b(B",
+    "\x1b(0x \x1b(B",
+    "\x1b(0~ \x1b(B",
+    "\x1b(0j \x1b(B",
+    "\x1b(0mq\x1b(B",
+    "\x1b(0vq\x1b(B",
+    "\x1b(0k \x1b(B",
+    "\x1b(0lq\x1b(B",
+    "\x1b(0wq\x1b(B",
+    "\x1b(0u \x1b(B",
+    "\x1b(0tq\x1b(B",
+    "\x1b(0nq\x1b(B",
+    "~ ",
+]
+
+
+def _pad_line_to_glyph(pl: PadLine) -> int:
+    if pl == PadLine.PARENT:
+        return PARENT
+    elif pl == PadLine.ANCESTOR:
+        return ANCESTOR
+    else:
+        return SPACE
+
+
+class BoxDrawingRenderer:
+    def __init__(self, inner: GraphRowRenderer, options: OutputRendererOptions) -> None:
+        self._inner = inner
+        self._options = options
+        self._extra_pad_line: str | None = None
+        self._glyphs: list[str] = CURVED_GLYPHS
+
+    def with_square_glyphs(self) -> BoxDrawingRenderer:
+        self._glyphs = SQUARE_GLYPHS
+        return self
+
+    def with_dec_graphics_glyphs(self) -> BoxDrawingRenderer:
+        self._glyphs = DEC_GLYPHS
+        return self
+
+    def width(
+        self,
+        node: object | None = None,
+        parents: list[AncestorType] | None = None,
+    ) -> int:
+        return self._inner.width(node, parents) * 2 + 1
+
+    def reserve(self, node: object) -> None:
+        self._inner.reserve(node)
+
+    def next_row(
+        self,
+        node: object,
+        parents: list[AncestorType],
+        glyph: str,
+        message: str,
+    ) -> str:
+        glyphs = self._glyphs
+        line = self._inner.next_row(node, parents, glyph, message)
+        out: list[str] = []
+        message_lines = pad_lines(
+            line.message.splitlines(), self._options.min_row_height
+        )
+        message_iter = iter(message_lines)
+        need_extra_pad_line = False
+
+        if self._extra_pad_line is not None:
+            out.append(self._extra_pad_line.rstrip())
+            out.append("\n")
+            self._extra_pad_line = None
+
+        # Node line
+        node_line_str = ""
+        for entry in line.node_line:
+            if entry == NodeLine.NODE:
+                node_line_str += line.glyph + " "
+            elif entry == NodeLine.PARENT:
+                node_line_str += glyphs[PARENT]
+            elif entry == NodeLine.ANCESTOR:
+                node_line_str += glyphs[ANCESTOR]
+            else:
+                node_line_str += glyphs[SPACE]
+        msg = next(message_iter, None)
+        if msg is not None:
+            node_line_str += " " + msg
+        out.append(node_line_str.rstrip())
+        out.append("\n")
+
+        # Link line
+        if line.link_line is not None:
+            link_row = line.link_line
+            link_line_str = ""
+            for cur in link_row:
+                if cur.intersects(LinkLine.HORIZONTAL):
+                    if cur.intersects(LinkLine.CHILD):
+                        link_line_str += glyphs[JOIN_BOTH]
+                    elif cur.intersects(LinkLine.ANY_FORK) and cur.intersects(
+                        LinkLine.ANY_MERGE
+                    ):
+                        link_line_str += glyphs[JOIN_BOTH]
+                    elif (
+                        cur.intersects(LinkLine.ANY_FORK)
+                        and cur.intersects(LinkLine.VERT_PARENT)
+                        and not line.merge
+                    ):
+                        link_line_str += glyphs[JOIN_BOTH]
+                    elif cur.intersects(LinkLine.ANY_FORK):
+                        link_line_str += glyphs[FORK_BOTH]
+                    elif cur.intersects(LinkLine.ANY_MERGE):
+                        link_line_str += glyphs[MERGE_BOTH]
+                    else:
+                        link_line_str += glyphs[HORIZONTAL]
+                elif cur.intersects(LinkLine.VERT_PARENT) and not line.merge:
+                    left = cur.intersects(LinkLine.LEFT_MERGE | LinkLine.LEFT_FORK)
+                    right = cur.intersects(
+                        LinkLine.RIGHT_MERGE | LinkLine.RIGHT_FORK
+                    )
+                    if left and right:
+                        link_line_str += glyphs[JOIN_BOTH]
+                    elif left:
+                        link_line_str += glyphs[JOIN_LEFT]
+                    elif right:
+                        link_line_str += glyphs[JOIN_RIGHT]
+                    else:
+                        link_line_str += glyphs[PARENT]
+                elif cur.intersects(
+                    LinkLine.VERT_PARENT | LinkLine.VERT_ANCESTOR
+                ) and not cur.intersects(LinkLine.LEFT_FORK | LinkLine.RIGHT_FORK):
+                    left = cur.intersects(LinkLine.LEFT_MERGE)
+                    right = cur.intersects(LinkLine.RIGHT_MERGE)
+                    if left and right:
+                        link_line_str += glyphs[JOIN_BOTH]
+                    elif left:
+                        link_line_str += glyphs[JOIN_LEFT]
+                    elif right:
+                        link_line_str += glyphs[JOIN_RIGHT]
+                    else:
+                        if cur.intersects(LinkLine.VERT_ANCESTOR):
+                            link_line_str += glyphs[ANCESTOR]
+                        else:
+                            link_line_str += glyphs[PARENT]
+                elif cur.intersects(LinkLine.LEFT_FORK) and cur.intersects(
+                    LinkLine.LEFT_MERGE | LinkLine.CHILD
+                ):
+                    link_line_str += glyphs[JOIN_LEFT]
+                elif cur.intersects(LinkLine.RIGHT_FORK) and cur.intersects(
+                    LinkLine.RIGHT_MERGE | LinkLine.CHILD
+                ):
+                    link_line_str += glyphs[JOIN_RIGHT]
+                elif cur.intersects(LinkLine.LEFT_MERGE) and cur.intersects(
+                    LinkLine.RIGHT_MERGE
+                ):
+                    link_line_str += glyphs[MERGE_BOTH]
+                elif cur.intersects(LinkLine.LEFT_FORK) and cur.intersects(
+                    LinkLine.RIGHT_FORK
+                ):
+                    link_line_str += glyphs[FORK_BOTH]
+                elif cur.intersects(LinkLine.LEFT_FORK):
+                    link_line_str += glyphs[FORK_LEFT]
+                elif cur.intersects(LinkLine.LEFT_MERGE):
+                    link_line_str += glyphs[MERGE_LEFT]
+                elif cur.intersects(LinkLine.RIGHT_FORK):
+                    link_line_str += glyphs[FORK_RIGHT]
+                elif cur.intersects(LinkLine.RIGHT_MERGE):
+                    link_line_str += glyphs[MERGE_RIGHT]
+                else:
+                    link_line_str += glyphs[SPACE]
+
+            msg = next(message_iter, None)
+            if msg is not None:
+                link_line_str += " " + msg
+            out.append(link_line_str.rstrip())
+            out.append("\n")
+
+        # Term line
+        if line.term_line is not None:
+            term_row = line.term_line
+            term_strs = [glyphs[PARENT], glyphs[TERMINATION]]
+            for term_str in term_strs:
+                term_line_str = ""
+                for i, term in enumerate(term_row):
+                    if term:
+                        term_line_str += term_str
+                    else:
+                        term_line_str += glyphs[_pad_line_to_glyph(line.pad_lines[i])]
+                msg = next(message_iter, None)
+                if msg is not None:
+                    term_line_str += " " + msg
+                out.append(term_line_str.rstrip())
+                out.append("\n")
+            need_extra_pad_line = True
+
+        # Base pad line
+        base_pad_line = ""
+        for entry in line.pad_lines:
+            base_pad_line += glyphs[_pad_line_to_glyph(entry)]
+
+        # Remaining message lines
+        for msg in message_iter:
+            pad_line = base_pad_line + " " + msg
+            out.append(pad_line.rstrip())
+            out.append("\n")
+            need_extra_pad_line = False
+
+        if need_extra_pad_line:
+            self._extra_pad_line = base_pad_line
+
+        return "".join(out)

renderdag/_column.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Hashable, TypeVar
+
+N = TypeVar("N", bound=Hashable)
+
+
+class Column:
+    __slots__ = ()
+
+    def matches(self, n: object) -> bool:
+        return False
+
+    def variant(self) -> int:
+        raise NotImplementedError
+
+    def merge(self, other: Column) -> Column:
+        if other.variant() > self.variant():
+            return other
+        return self
+
+    def reset(self) -> Column:
+        return self
+
+    def clone(self) -> Column:
+        return self
+
+
+class _Empty(Column):
+    __slots__ = ()
+
+    def variant(self) -> int:
+        return 0
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, _Empty)
+
+    def __repr__(self) -> str:
+        return "EMPTY"
+
+
+class _Blocked(Column):
+    __slots__ = ()
+
+    def variant(self) -> int:
+        return 1
+
+    def reset(self) -> Column:
+        return EMPTY
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, _Blocked)
+
+    def __repr__(self) -> str:
+        return "BLOCKED"
+
+
+EMPTY = _Empty()
+BLOCKED = _Blocked()
+
+
+@dataclass(slots=True)
+class Reserved(Column):
+    node: object
+
+    def matches(self, n: object) -> bool:
+        return self.node == n
+
+    def variant(self) -> int:
+        return 2
+
+    def clone(self) -> Column:
+        return Reserved(self.node)
+
+
+@dataclass(slots=True)
+class Ancestor(Column):
+    node: object
+
+    def matches(self, n: object) -> bool:
+        return self.node == n
+
+    def variant(self) -> int:
+        return 3
+
+    def clone(self) -> Column:
+        return Ancestor(self.node)
+
+
+@dataclass(slots=True)
+class Parent(Column):
+    node: object
+
+    def matches(self, n: object) -> bool:
+        return self.node == n
+
+    def variant(self) -> int:
+        return 4
+
+    def clone(self) -> Column:
+        return Parent(self.node)
+
+
+def columns_find(columns: list[Column], node: object) -> int | None:
+    for i, col in enumerate(columns):
+        if col.matches(node):
+            return i
+    return None
+
+
+def columns_find_empty(columns: list[Column], index: int) -> int | None:
+    if index < len(columns) and columns[index] == EMPTY:
+        return index
+    return columns_first_empty(columns)
+
+
+def columns_first_empty(columns: list[Column]) -> int | None:
+    for i, col in enumerate(columns):
+        if col == EMPTY:
+            return i
+    return None
+
+
+def columns_new_empty(columns: list[Column]) -> int:
+    columns.append(EMPTY)
+    return len(columns) - 1
+
+
+def columns_reset(columns: list[Column]) -> None:
+    for i in range(len(columns)):
+        columns[i] = columns[i].reset()
+    while columns and columns[-1] == EMPTY:
+        columns.pop()

renderdag/_output.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ._render import GraphRowRenderer
+
+
+@dataclass
+class OutputRendererOptions:
+    min_row_height: int = 2
+
+
+class OutputRendererBuilder:
+    def __init__(self, inner: GraphRowRenderer) -> None:
+        self._inner = inner
+        self._options = OutputRendererOptions()
+
+    def with_min_row_height(self, min_row_height: int) -> OutputRendererBuilder:
+        self._options.min_row_height = min_row_height
+        return self
+
+    def build_ascii(self) -> "AsciiRenderer":
+        from ._ascii import AsciiRenderer
+
+        return AsciiRenderer(self._inner, self._options)
+
+    def build_ascii_large(self) -> "AsciiLargeRenderer":
+        from ._ascii_large import AsciiLargeRenderer
+
+        return AsciiLargeRenderer(self._inner, self._options)
+
+    def build_box_drawing(self) -> "BoxDrawingRenderer":
+        from ._box_drawing import BoxDrawingRenderer
+
+        return BoxDrawingRenderer(self._inner, self._options)

renderdag/_pad.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+
+def pad_lines(lines: list[str], min_count: int) -> Iterator[str]:
+    index = 0
+    for line in lines:
+        index += 1
+        yield line
+    while index < min_count:
+        index += 1
+        yield ""

renderdag/_render.py

@@ -0,0 +1,411 @@
+from __future__ import annotations
+
+import enum
+from dataclasses import dataclass, field
+from typing import Optional
+
+from ._column import (
+    BLOCKED,
+    EMPTY,
+    Column,
+    columns_find,
+    columns_find_empty,
+    columns_first_empty,
+    columns_new_empty,
+    columns_reset,
+)
+from ._column import Ancestor as ColumnAncestor
+from ._column import Parent as ColumnParent
+
+
+class AncestorType:
+    __slots__ = ()
+
+    def id(self) -> object | None:
+        raise NotImplementedError
+
+    def is_direct(self) -> bool:
+        raise NotImplementedError
+
+    def to_link_line(self, direct: LinkLine, indirect: LinkLine) -> LinkLine:
+        return direct if self.is_direct() else indirect
+
+    def to_column(self) -> Column:
+        raise NotImplementedError
+
+
+class AncestorAncestor(AncestorType):
+    __slots__ = ("node",)
+
+    def __init__(self, node: object) -> None:
+        self.node = node
+
+    def id(self) -> object | None:
+        return self.node
+
+    def is_direct(self) -> bool:
+        return False
+
+    def to_column(self) -> Column:
+        return ColumnAncestor(self.node)
+
+    def __repr__(self) -> str:
+        return f"Ancestor.ancestor({self.node!r})"
+
+
+class AncestorParent(AncestorType):
+    __slots__ = ("node",)
+
+    def __init__(self, node: object) -> None:
+        self.node = node
+
+    def id(self) -> object | None:
+        return self.node
+
+    def is_direct(self) -> bool:
+        return True
+
+    def to_column(self) -> Column:
+        return ColumnParent(self.node)
+
+    def __repr__(self) -> str:
+        return f"Ancestor.parent({self.node!r})"
+
+
+class AncestorAnonymous(AncestorType):
+    __slots__ = ()
+
+    def id(self) -> object | None:
+        return None
+
+    def is_direct(self) -> bool:
+        return True
+
+    def to_column(self) -> Column:
+        return BLOCKED
+
+    def __repr__(self) -> str:
+        return "Ancestor.anonymous()"
+
+
+class Ancestor:
+    @staticmethod
+    def ancestor(node: object) -> AncestorType:
+        return AncestorAncestor(node)
+
+    @staticmethod
+    def parent(node: object) -> AncestorType:
+        return AncestorParent(node)
+
+    @staticmethod
+    def anonymous() -> AncestorType:
+        return AncestorAnonymous()
+
+
+class NodeLine(enum.Enum):
+    BLANK = 0
+    ANCESTOR = 1
+    PARENT = 2
+    NODE = 3
+
+
+class PadLine(enum.Enum):
+    BLANK = 0
+    ANCESTOR = 1
+    PARENT = 2
+
+
+class LinkLine(enum.IntFlag):
+    HORIZ_PARENT = 0b0_0000_0000_0001
+    HORIZ_ANCESTOR = 0b0_0000_0000_0010
+    VERT_PARENT = 0b0_0000_0000_0100
+    VERT_ANCESTOR = 0b0_0000_0000_1000
+    LEFT_FORK_PARENT = 0b0_0000_0001_0000
+    LEFT_FORK_ANCESTOR = 0b0_0000_0010_0000
+    RIGHT_FORK_PARENT = 0b0_0000_0100_0000
+    RIGHT_FORK_ANCESTOR = 0b0_0000_1000_0000
+    LEFT_MERGE_PARENT = 0b0_0001_0000_0000
+    LEFT_MERGE_ANCESTOR = 0b0_0010_0000_0000
+    RIGHT_MERGE_PARENT = 0b0_0100_0000_0000
+    RIGHT_MERGE_ANCESTOR = 0b0_1000_0000_0000
+    CHILD = 0b1_0000_0000_0000
+
+    HORIZONTAL = HORIZ_PARENT | HORIZ_ANCESTOR
+    VERTICAL = VERT_PARENT | VERT_ANCESTOR
+    LEFT_FORK = LEFT_FORK_PARENT | LEFT_FORK_ANCESTOR
+    RIGHT_FORK = RIGHT_FORK_PARENT | RIGHT_FORK_ANCESTOR
+    LEFT_MERGE = LEFT_MERGE_PARENT | LEFT_MERGE_ANCESTOR
+    RIGHT_MERGE = RIGHT_MERGE_PARENT | RIGHT_MERGE_ANCESTOR
+    ANY_MERGE = LEFT_MERGE | RIGHT_MERGE
+    ANY_FORK = LEFT_FORK | RIGHT_FORK
+    ANY_FORK_OR_MERGE = ANY_MERGE | ANY_FORK
+
+    def intersects(self, other: LinkLine) -> bool:
+        return bool(self & other)
+
+
+def _empty_link_line() -> LinkLine:
+    return LinkLine(0)
+
+
+def _column_to_node_line(col: Column) -> NodeLine:
+    if isinstance(col, ColumnAncestor):
+        return NodeLine.ANCESTOR
+    if isinstance(col, ColumnParent):
+        return NodeLine.PARENT
+    return NodeLine.BLANK
+
+
+def _column_to_link_line(col: Column) -> LinkLine:
+    if isinstance(col, ColumnAncestor):
+        return LinkLine.VERT_ANCESTOR
+    if isinstance(col, ColumnParent):
+        return LinkLine.VERT_PARENT
+    return _empty_link_line()
+
+
+def _column_to_pad_line(col: Column) -> PadLine:
+    if isinstance(col, ColumnAncestor):
+        return PadLine.ANCESTOR
+    if isinstance(col, ColumnParent):
+        return PadLine.PARENT
+    return PadLine.BLANK
+
+
+@dataclass
+class _AncestorColumnBounds:
+    target: int
+    min_ancestor: int
+    min_parent: int
+    max_parent: int
+    max_ancestor: int
+
+    @staticmethod
+    def from_columns(
+        columns: dict[int, AncestorType], target: int
+    ) -> Optional[_AncestorColumnBounds]:
+        if not columns:
+            return None
+        sorted_keys = sorted(columns.keys())
+        min_ancestor = min(sorted_keys[0], target)
+        max_ancestor = max(sorted_keys[-1], target)
+
+        direct_keys = [k for k in sorted_keys if columns[k].is_direct()]
+        min_parent = min(direct_keys[0], target) if direct_keys else target
+        max_parent = max(direct_keys[-1], target) if direct_keys else target
+
+        return _AncestorColumnBounds(
+            target=target,
+            min_ancestor=min_ancestor,
+            min_parent=min_parent,
+            max_parent=max_parent,
+            max_ancestor=max_ancestor,
+        )
+
+    def range(self) -> range:
+        if self.min_ancestor < self.max_ancestor:
+            return range(self.min_ancestor + 1, self.max_ancestor)
+        return range(0, 0)
+
+    def horizontal_line(self, index: int) -> LinkLine:
+        if index == self.target:
+            return _empty_link_line()
+        elif index > self.min_parent and index < self.max_parent:
+            return LinkLine.HORIZ_PARENT
+        elif index > self.min_ancestor and index < self.max_ancestor:
+            return LinkLine.HORIZ_ANCESTOR
+        else:
+            return _empty_link_line()
+
+
+@dataclass
+class GraphRow:
+    node: object
+    glyph: str
+    message: str
+    merge: bool
+    node_line: list[NodeLine]
+    link_line: list[LinkLine] | None
+    term_line: list[bool] | None
+    pad_lines: list[PadLine]
+
+
+class GraphRowRenderer:
+    def __init__(self) -> None:
+        self._columns: list[Column] = []
+
+    def width(
+        self,
+        node: object | None = None,
+        parents: list[AncestorType] | None = None,
+    ) -> int:
+        width = len(self._columns)
+        empty_columns = sum(1 for c in self._columns if c == EMPTY)
+        if node is not None:
+            if columns_find(self._columns, node) is None:
+                if empty_columns == 0:
+                    width += 1
+                else:
+                    empty_columns = max(0, empty_columns - 1)
+        if parents is not None:
+            unallocated = 0
+            for p in parents:
+                pid = p.id()
+                if pid is None or columns_find(self._columns, pid) is None:
+                    unallocated += 1
+            unallocated = max(0, unallocated - empty_columns)
+            width += max(0, unallocated - 1)
+        return width
+
+    def reserve(self, node: object) -> None:
+        from ._column import Reserved
+
+        if columns_find(self._columns, node) is None:
+            idx = columns_first_empty(self._columns)
+            if idx is not None:
+                self._columns[idx] = Reserved(node)
+            else:
+                self._columns.append(Reserved(node))
+
+    def next_row(
+        self,
+        node: object,
+        parents: list[AncestorType],
+        glyph: str,
+        message: str,
+    ) -> GraphRow:
+        column = columns_find(self._columns, node)
+        if column is None:
+            column = columns_first_empty(self._columns)
+            if column is None:
+                column = columns_new_empty(self._columns)
+        self._columns[column] = EMPTY
+
+        merge = len(parents) > 1
+
+        node_line = [_column_to_node_line(c) for c in self._columns]
+        node_line[column] = NodeLine.NODE
+
+        link_line = [_column_to_link_line(c) for c in self._columns]
+        need_link_line = False
+
+        term_line = [False] * len(self._columns)
+        need_term_line = False
+
+        pad_lines_list = [_column_to_pad_line(c) for c in self._columns]
+
+        parent_columns: dict[int, AncestorType] = {}
+        for p in parents:
+            pid = p.id()
+            if pid is not None:
+                idx = columns_find(self._columns, pid)
+                if idx is not None:
+                    self._columns[idx] = self._columns[idx].merge(p.to_column())
+                    parent_columns[idx] = p
+                    continue
+
+            idx = columns_find_empty(self._columns, column)
+            if idx is not None:
+                self._columns[idx] = self._columns[idx].merge(p.to_column())
+                parent_columns[idx] = p
+                continue
+
+            parent_columns[len(self._columns)] = p
+            node_line.append(NodeLine.BLANK)
+            pad_lines_list.append(PadLine.BLANK)
+            link_line.append(_empty_link_line())
+            term_line.append(False)
+            self._columns.append(p.to_column())
+
+        for i, p in parent_columns.items():
+            if p.id() is None:
+                term_line[i] = True
+                need_term_line = True
+
+        if len(parents) == 1:
+            sorted_pc = sorted(parent_columns.items())
+            if sorted_pc:
+                parent_column, _ = sorted_pc[0]
+                if parent_column > column:
+                    self._columns[column], self._columns[parent_column] = (
+                        self._columns[parent_column],
+                        self._columns[column],
+                    )
+                    parent = parent_columns.pop(parent_column)
+                    parent_columns[column] = parent
+
+                    was_direct = bool(
+                        link_line[parent_column] & LinkLine.VERT_PARENT
+                    )
+                    link_line[column] |= (
+                        LinkLine.RIGHT_FORK_PARENT
+                        if was_direct
+                        else LinkLine.RIGHT_FORK_ANCESTOR
+                    )
+                    for i in range(column + 1, parent_column):
+                        link_line[i] |= (
+                            LinkLine.HORIZ_PARENT
+                            if was_direct
+                            else LinkLine.HORIZ_ANCESTOR
+                        )
+                    link_line[parent_column] = (
+                        LinkLine.LEFT_MERGE_PARENT
+                        if was_direct
+                        else LinkLine.LEFT_MERGE_ANCESTOR
+                    )
+                    need_link_line = True
+                    pad_lines_list[parent_column] = PadLine.BLANK
+
+        bounds = _AncestorColumnBounds.from_columns(parent_columns, column)
+        if bounds is not None:
+            for i in bounds.range():
+                link_line[i] |= bounds.horizontal_line(i)
+                need_link_line = True
+
+            if bounds.max_parent > column:
+                link_line[column] |= LinkLine.RIGHT_MERGE_PARENT
+                need_link_line = True
+            elif bounds.max_ancestor > column:
+                link_line[column] |= LinkLine.RIGHT_MERGE_ANCESTOR
+                need_link_line = True
+
+            if bounds.min_parent < column:
+                link_line[column] |= LinkLine.LEFT_MERGE_PARENT
+                need_link_line = True
+            elif bounds.min_ancestor < column:
+                link_line[column] |= LinkLine.LEFT_MERGE_ANCESTOR
+                need_link_line = True
+
+            for i in sorted(parent_columns.keys()):
+                p = parent_columns[i]
+                pad_lines_list[i] = _column_to_pad_line(self._columns[i])
+                if i < column:
+                    link_line[i] |= p.to_link_line(
+                        LinkLine.RIGHT_FORK_PARENT, LinkLine.RIGHT_FORK_ANCESTOR
+                    )
+                elif i == column:
+                    link_line[i] |= LinkLine.CHILD | p.to_link_line(
+                        LinkLine.VERT_PARENT, LinkLine.VERT_ANCESTOR
+                    )
+                else:
+                    link_line[i] |= p.to_link_line(
+                        LinkLine.LEFT_FORK_PARENT, LinkLine.LEFT_FORK_ANCESTOR
+                    )
+
+        columns_reset(self._columns)
+
+        return GraphRow(
+            node=node,
+            glyph=glyph,
+            message=message,
+            merge=merge,
+            node_line=node_line,
+            link_line=link_line if need_link_line else None,
+            term_line=term_line if need_term_line else None,
+            pad_lines=pad_lines_list,
+        )
+
+    def output(self) -> "OutputRendererBuilder":
+        from ._output import OutputRendererBuilder
+
+        return OutputRendererBuilder(self)

renderdag-0.1.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.3
+Name: renderdag
+Version: 0.1.0
+Summary: Render directed acyclic graphs (DAGs) as text, ported from sapling-renderdag
+Keywords: dag,graph,visualization,git,terminal
+Author: Sam Watson
+Author-email: Sam Watson <sam.watson@aprioriinvestments.com>
+License: MIT License
+         
+         Copyright (c) Meta Platforms, Inc. and affiliates.
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# renderdag
+
+A Python port of Meta's [sapling-renderdag](https://github.com/facebook/sapling/tree/main/eden/scm/lib/renderdag) Rust library for rendering directed acyclic graphs (DAGs) as text.
+
+
+## Renderers
+
+**ASCII** — basic characters, compact:
+
+```
+o    E  merge commit
+|\
+o |  D
+| |
+| o  C  branch
+|/
+o  B
+|
+o  A
+```
+
+**ASCII Large** — wider spacing, easier to read:
+
+```
+o     E  merge commit
+|\
+| \
+o  |  D
+|  |
+|  o  C  branch
+| /
+|/
+o  B
+|
+o  A
+```
+
+**Box Drawing** — Unicode line-drawing characters:
+
+```
+o    E  merge commit
+├─╮
+o │  D
+│ │
+│ o  C  branch
+├─╯
+o  B
+│
+o  A
+```
+
+## Install
+
+```
+pip install renderdag
+# or
+uv add renderdag
+```
+
+## Usage
+
+```python
+from renderdag import Ancestor, GraphRowRenderer
+
+renderer = GraphRowRenderer().output().build_box_drawing()
+
+# Render rows top-down (most recent commit first)
+print(renderer.next_row("C", [Ancestor.parent("B")], "o", "C  latest"))
+print(renderer.next_row("B", [Ancestor.parent("A")], "o", "B"))
+print(renderer.next_row("A", [], "o", "A  root"))
+```
+
+The API follows a row-at-a-time model: call `next_row()` for each node in topological order (heads first), passing the node identifier, its parents as `Ancestor` values, a glyph string, and a message. The renderer tracks column state and returns the formatted string for that row.
+
+### Ancestor types
+
+- `Ancestor.parent(node)` — direct parent (solid line)
+- `Ancestor.ancestor(node)` — indirect ancestor (dotted line)
+- `Ancestor.anonymous()` — unknown/missing parent (terminator `~`)
+
+### Builder options
+
+```python
+# ASCII renderer
+renderer = GraphRowRenderer().output().build_ascii()
+
+# ASCII Large with taller rows
+renderer = GraphRowRenderer().output().with_min_row_height(3).build_ascii_large()
+
+# Box Drawing with square corners instead of curved
+renderer = GraphRowRenderer().output().build_box_drawing().with_square_glyphs()
+
+# Reserve a column for a node before it appears
+renderer.reserve("some-node")
+```
+
+## Development
+
+Requires [uv](https://docs.astral.sh/uv/) and [just](https://just.systems/).
+
+```
+just demo          # see example output from all renderers
+just test          # run all tests
+just test-fast     # skip Rust cross-validation
+just test-xval     # run only Rust cross-validation
+```
+
+## License
+
+MIT. This is a derivative work of [sapling-renderdag](https://github.com/facebook/sapling/tree/main/eden/scm/lib/renderdag) by Meta Platforms, Inc. See [LICENSE](LICENSE) for details.
+
+*Note: this library was created using LLMs.*
+

renderdag-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+renderdag/__init__.py,sha256=0R4VY2m7z4DYZEW5eGjNREbLfSxCsyGfwV3wxpIIv7E,469
+renderdag/_ascii.py,sha256=xIp0Y-Ir7JHQWHDZ_Pjf9CnzOoIe_IRjsz0FbsjU0y0,5749
+renderdag/_ascii_large.py,sha256=qTGpF3OJvGGbSjBmKaZF2Cg-EEaRFP6b7P6CsCRmbeI,6837
+renderdag/_box_drawing.py,sha256=OflEyN-1JOfPBFAooRU9hG6IcgpphTHqPFLQi2Qr2xM,8593
+renderdag/_column.py,sha256=vNQQTG6TxpDiy-b1YFIxqf3frXMNZPe6ErmEWpXi9yQ,2703
+renderdag/_output.py,sha256=ugfJfljz4ZooNV7i1SA7Sra2qS_KsrBUfDU_kVMczf0,994
+renderdag/_pad.py,sha256=1CqOER19n8_8lp3Fkky0qxbvItbRpy8iZq43mGZ--RA,272
+renderdag/_render.py,sha256=lT32XnXhNZj4gem6-_LtYDndei-Lo7rA-YNSZsl0eU0,12597
+renderdag/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+renderdag-0.1.0.dist-info/WHEEL,sha256=QnGI6l9Psotmz6XrseXTYT5jnZRJeTk4SwJP4aLtfdI,80
+renderdag-0.1.0.dist-info/METADATA,sha256=v58ZRfok8cJyiLX2VH3npS291FpiPMcck6iJspXAQ10,4569
+renderdag-0.1.0.dist-info/RECORD,,

renderdag-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.10.2
+Root-Is-Purelib: true
+Tag: py3-none-any