pizza-lib 0.1.0__py3-none-any.whl

pizza_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: pizza-lib
+Version: 0.1.0
+Summary: Data structure and algorithm helpers for LeetCode-style Python: grids, adjacency, binary search bounds, heaps, trees, linked lists.
+Author: Shyal
+License: MIT
+Project-URL: Homepage, https://github.com/shyal/pydsa
+Project-URL: Repository, https://github.com/shyal/pydsa
+Keywords: leetcode,algorithms,data-structures,grid,graph,heap,binary-search
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Education
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: draw
+Requires-Dist: rich; extra == "draw"
+Requires-Dist: colorama; extra == "draw"
+Requires-Dist: PrettyPrintTree; extra == "draw"
+Requires-Dist: graphviz; extra == "draw"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# pydsa
+
+Data structure and algorithm helpers for LeetCode-style Python: the
+functions one keeps rewriting at the top of a solution, written once and
+tested.
+
+```
+pip install pizza-lib   # the import name is pydsa
+```
+
+```python
+from pydsa import table, cells, nbrs, first_true, Multiset, maxheappush
+
+dp = table(3, 4)                      # a 3 by 4 grid of zeros
+for i, j in cells(grid):              # every cell, row by row
+    for ni, nj in nbrs(grid, i, j):   # its on-grid neighbours
+        ...
+first_true(1, 10**9, lambda x: x * x >= n)   # the first x in [1, 10^9] with ok(x)
+```
+
+## Modules
+
+| Module | Names |
+| --- | --- |
+| `grid` | `table`, `like`, `shape`, `cells`, `nbrs`, `in_bounds`, `is_edge`, `edges`, `put`, `row`, `col`, `set_row`, `set_col`, `grid_bfs`, `CARDINALS`, `DIAGONALS`, `ALL_EIGHT` |
+| `adj` | `adjacency`, `indegrees`, `levels`, `components`, `Graph`, `graph`, `dijkstra` |
+| `search` | `first_true`, `last_true`, `first_false`, `last_false`, `min_chunks`, `viz_binary_search` |
+| `heaps` | `maxheappush`, `maxheappop`, `maxheapify`, `maxheappushpop`, `maxheapreplace`, `maxheappeek`, `maxheapitems`, `heap`, `draw_heap` |
+| `counting` | `Multiset`, `count_pairs` |
+| `combo` | `pairs`, `triples` |
+| `digits` | `to_digits`, `to_int`, `even`, `odd` |
+| `arith` | `ceil_div`, `batched` |
+| `seq` | `lcs` |
+| `generators` | `as_list` |
+| `nodes` | `TreeNode`, `ListNode`, `GraphNode`, `Node` |
+| `tree` | `build_tree`, `get_level_order`, `find_node`, `get_inorder`, `is_balanced`, `build_nary_tree`, `build_general_tree`, `get_general_tree`, `generate_random_tree`, `generate_full_binary_tree`, `draw_tree`, `draw_general_tree` |
+| `bst` | `insert`, `generate_random_bst`, `tree_to_list`, `is_valid_bst`, `generate_and_print_random_bst` |
+| `linked` | `build_linked_list`, `get_list_values`, `print_linked_list`, `linked_list_reverse_k`, `draw_linked_list` |
+| `graphs` | `build_graph`, `get_adj_list`, `build_graph_from_edge_list`, `as_dict_of_dicts`, `is_edge_list`, `draw_graph`, `draw_graphviz`, `draw_ascii_graph` |
+
+Every public name is importable from the package itself. The package
+imports only the standard library. The `draw_*` functions, `tabulate`-style
+output and `viz_binary_search` import rich, colorama, PrettyPrintTree and
+graphviz when first called:
+
+```
+pip install 'pizza-lib[draw]'
+```
+
+Every function has a docstring with its contract; the tests in `tests/`
+are the examples.
+
+## Where it comes from
+
+These helpers were the harness of the `leet` repo, preloaded into
+`builtins` for every solve there, and the library that the `mu` language
+pastes into the Python it emits. Both still use them from here.
+
+## Tests
+
+```
+pip install -e '.[test]'
+pytest
+```

pizza_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+pizza_lib-0.1.0.dist-info/licenses/LICENSE,sha256=vOQUZGMtzHZUlEUJS8CIA0smrZ10pfWGVC4fRC4qBcs,1062
+pydsa/__init__.py,sha256=aAtJdSX_fcZsEwzwaTiEGUACy221kJ9BZMZ1dWISOik,942
+pydsa/_treeformat.py,sha256=XiIh8kyEk0QFcyHKvzZQUL-Yz1bzPSULSl7MkBTiNBw,8871
+pydsa/adj.py,sha256=jCnqZNUML2Qbrh_wOGumcnIG5VAjLu2JLEIjaycRcDQ,5192
+pydsa/arith.py,sha256=a-QnwA7kuJIg6A6xGXyKQP8sDOLszaNMeOHwgBQOiig,591
+pydsa/bst.py,sha256=ar51gVTepAKDid-ACWJUih-btZlY1I2c0NQLy4ADrNo,2144
+pydsa/combo.py,sha256=rV6LNm2Q_bb6AcF0HDby1EyIKN5mB6YIot84_Q1BAGc,1228
+pydsa/counting.py,sha256=uo4t2oi0iyPEN2Q3SuxFZ1gq3AG7S57p-qDXgcy4Apk,2046
+pydsa/digits.py,sha256=GnbbGELQH9N8qWdwBLvr59neEtG3EG0giwUaGSUk2Co,1493
+pydsa/generators.py,sha256=J-uZ1Bd4xVO5lj0Dbd5GT1IhrVsW1SQv9aDxmAuz9gA,549
+pydsa/graphs.py,sha256=5pYlDB9SGAYPuymkq8dq6gXmyvfQv7UMT7kq0eHs8lY,13842
+pydsa/grid.py,sha256=iWLN-eFJ7vC_6cT_XnoB2Li2rY3KNGvKjDR4zwvkJ9w,6736
+pydsa/heaps.py,sha256=mRKk9uvfsvaCU0cm2s4kd1EGLSkIzfRjU7Sbs3gP0GQ,3273
+pydsa/linked.py,sha256=CoRkhdSvEV4rxHJxGLKCtqSGeuk8LrDtTdPhFiforeM,1864
+pydsa/nodes.py,sha256=moX0ROFsHx81qlfPTtkFw6XDxp5KrytFabIsENJLTH8,1907
+pydsa/search.py,sha256=lXkzhZDQST3Dasaih8Pto4TvzItrRg5SMS-IQE4M8DQ,8282
+pydsa/seq.py,sha256=yiVNM2s91qYDaPKr0__M4oDswXjzzRwpOqIjW_bk98Q,942
+pydsa/tree.py,sha256=bBJbTiLW2IDGdWiKQFDiDlv57lF0FZYYnvo3JQqfhqM,9564
+pizza_lib-0.1.0.dist-info/METADATA,sha256=ryXhtaqCPQYcp4QZ3hdWaRtaViOsJUdzoTk_nmB80-w,3660
+pizza_lib-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pizza_lib-0.1.0.dist-info/top_level.txt,sha256=lv_hZp9lUdb6dd-5ucCTCquBfyW9892YzMJgaIkoaeM,6
+pizza_lib-0.1.0.dist-info/RECORD,,

pizza_lib-0.1.0.dist-info/WHEEL

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

pizza_lib-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shyal
+
+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.

pizza_lib-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pydsa

pydsa/__init__.py

@@ -0,0 +1,25 @@
+"""pydsa: data structures and algorithm helpers for LeetCode-style Python.
+
+Every public name of every module is importable from the package. The
+package imports only the standard library; the drawing functions import
+rich, colorama, PrettyPrintTree and graphviz when first called
+(`pip install pydsa[draw]`).
+"""
+
+from .adj import *  # noqa: F401,F403
+from .arith import *  # noqa: F401,F403
+from .bst import *  # noqa: F401,F403
+from .combo import *  # noqa: F401,F403
+from .counting import *  # noqa: F401,F403
+from .digits import *  # noqa: F401,F403
+from .generators import *  # noqa: F401,F403
+from .graphs import *  # noqa: F401,F403
+from .grid import *  # noqa: F401,F403
+from .heaps import *  # noqa: F401,F403
+from .linked import *  # noqa: F401,F403
+from .nodes import *  # noqa: F401,F403
+from .search import *  # noqa: F401,F403
+from .seq import *  # noqa: F401,F403
+from .tree import *  # noqa: F401,F403
+
+__version__ = "0.1.0"

pydsa/_treeformat.py

@@ -0,0 +1,224 @@
+from typing import Any, Callable, Generic, Iterable, TypeVar
+
+from PrettyPrint.PrintTree.HorizontalTree import (
+    add_parent as add_parent_left,
+)
+from PrettyPrint.PrintTree.HorizontalTree import (
+    join_vertically,
+)
+from PrettyPrint.PrintTree.VerticalTree import (
+    add_parent as add_parent_top,
+)
+from PrettyPrint.PrintTree.VerticalTree import (
+    join_horizontally,
+)
+from PrettyPrint.Utils.NodeFormatter import NodeFormatter
+from PrettyPrint.Utils.Orientation import Orientation
+from PrettyPrint.Utils.StyleAwareUtils import trim_text
+
+T = TypeVar("T")
+
+# ANSI escape codes for connector foreground colors
+RED = "\033[31m"
+BLUE = "\033[34m"
+RESET = "\033[0m"
+
+
+class TreeFormatter(Generic[T]):
+    def __init__(
+        self,
+        get_children: Callable[[T], Iterable[T]],
+        get_val: Callable[[T], Any],
+        get_label: Callable[[T], Any] | None,
+        label_color: str,
+        show_newline_literal: bool,
+        newline_literal: str,
+        trim: int,
+        trim_symbol: str,
+        start_message: Callable[[T], str] | None,
+        color: str,
+        border: bool,
+        max_depth: int,
+        orientation: bool,
+    ):
+        self.get_children = get_children
+        self.get_node_val = get_val
+        self.get_label = get_label
+        self.label_color = label_color
+        self.trim = trim
+        self.trim_symbol = trim_symbol
+        self.show_newline = show_newline_literal
+        self.newline_literal = newline_literal
+        self.start_message = start_message
+        self.color = color
+        self.border = border
+        self.max_depth = max_depth
+        self.orientation = orientation
+
+    def format(self, node: T) -> str:
+        if self.orientation == Orientation.Vertical:
+            res = self.tree_vertical_join(node)
+        else:
+            res = self.tree_horizontal_join(node)
+        res = res.to_str().rstrip()
+        if self.start_message:
+            return f"{ self.start_message(node) }\n{ res }"
+        return res
+
+    def tree_vertical_join(
+        self, tree_node: T, depth: int = 0, is_left: bool | None = None
+    ) -> NodeFormatter:
+        """
+        tree_node: actual user tree node (T)
+        returns: NodeFormatter for the subtree rooted at tree_node
+        is_left: whether tree_node itself is a left child of its parent (used to color the connector to its parent)
+        """
+        label = self.get_label(tree_node) if self.get_label else None
+
+        # Get raw children as provided by get_children (may omit None)
+        children_raw = list(self.get_children(tree_node))
+
+        # Create NodeFormatter for current node (styles/colors/trim etc.)
+        node = self.add_styles(tree_node)
+
+        if children_raw and (self.max_depth == -1 or depth < self.max_depth):
+            # Build formatted children and remember whether each child is left/right
+            children_with_flags = []
+            for i, child in enumerate(children_raw):
+                # Determine is_left flag correctly for binary trees:
+                # - If two children are present, index 0 is left, index 1 is right.
+                # - If only one child is present, try to inspect tree_node.left/right attributes.
+                if len(children_raw) == 2:
+                    child_is_left = i == 0
+                elif len(children_raw) == 1:
+                    left_attr = getattr(tree_node, "left", object())
+                    right_attr = getattr(tree_node, "right", object())
+                    if child is left_attr:
+                        child_is_left = True
+                    elif child is right_attr:
+                        child_is_left = False
+                    else:
+                        # Fallback (best-effort): treat single child as left if we can't detect
+                        child_is_left = i == 0
+                else:
+                    # No children (shouldn't reach here because children_raw is truthy)
+                    child_is_left = None
+
+                child_fmt = self.tree_vertical_join(
+                    child, depth + 1, is_left=child_is_left
+                )
+                children_with_flags.append((child_fmt, child_is_left))
+
+            if len(children_with_flags) == 1:
+                # Single-child case: insert a colored '|' connector above the child
+                child_node_fmt, child_is_left = children_with_flags[0]
+                if child_is_left is True:
+                    edge_str = f"{RED}/{RESET}"
+                elif child_is_left is False:
+                    edge_str = f"{BLUE}\\{RESET}"
+                else:
+                    edge_str = "|"
+                child_node_fmt.lines.insert(
+                    0, " " * child_node_fmt.get_middle_width() + edge_str
+                )
+                children_node = child_node_fmt
+            else:
+                # Two children: join them horizontally (we rely on join_horizontally for placement)
+                children_node = join_horizontally(
+                    [fmt for fmt, _ in children_with_flags]
+                )
+
+            node = add_parent_top(node, children_node)
+
+        node = self.add_label(label, node, add_parent_top, "|")
+        return node
+
+    def tree_horizontal_join(
+        self, tree_node: T, depth: int = 0, is_left: bool | None = None
+    ) -> NodeFormatter:
+        """
+        Horizontal join variant (similar logic to vertical).
+        """
+        label = self.get_label(tree_node) if self.get_label else None
+        children_raw = list(self.get_children(tree_node))
+        node = self.add_styles(tree_node)
+        node_padding = " " * node.width
+        node.lines = node.lines + [node_padding]
+        node.height += 1
+
+        if children_raw and (self.max_depth == -1 or depth < self.max_depth):
+            children_with_flags = []
+            for i, child in enumerate(children_raw):
+                if len(children_raw) == 2:
+                    child_is_left = i == 0
+                elif len(children_raw) == 1:
+                    left_attr = getattr(tree_node, "left", object())
+                    right_attr = getattr(tree_node, "right", object())
+                    if child is left_attr:
+                        child_is_left = True
+                    elif child is right_attr:
+                        child_is_left = False
+                    else:
+                        child_is_left = i == 0
+                else:
+                    child_is_left = None
+
+                child_fmt = self.tree_horizontal_join(
+                    child, depth + 1, is_left=child_is_left
+                )
+                children_with_flags.append((child_fmt, child_is_left))
+
+            if len(children_with_flags) == 1:
+                children_node, child_is_left = children_with_flags[0]
+                middle = children_node.get_middle_height()
+                new_lines = []
+                for r_idx, line in enumerate(children_node.lines):
+                    if r_idx == middle:
+                        if child_is_left is True:
+                            edge_str = f"{RED}─{RESET}"
+                        elif child_is_left is False:
+                            edge_str = f"{BLUE}─{RESET}"
+                        else:
+                            edge_str = "─"
+                        new_lines.append(edge_str + line)
+                    else:
+                        new_lines.append(" " + line)
+                children_node.lines = new_lines
+            else:
+                children_node = join_vertically([fmt for fmt, _ in children_with_flags])
+
+            node = add_parent_left(node, children_node)
+
+        node = self.add_label(label, node, add_parent_left, "─")
+        return node
+
+    def add_label(
+        self,
+        label: Any,
+        node: NodeFormatter,
+        parent_adder: Callable[[NodeFormatter, NodeFormatter], NodeFormatter],
+        seperator: str,
+    ) -> NodeFormatter:
+        if label:
+            label = NodeFormatter.from_string(str(label))
+            if self.label_color:
+                label.color_bg(self.label_color, True)
+            node = parent_adder(NodeFormatter.from_string(seperator), node)
+            node = parent_adder(label, node)
+        return node
+
+    def add_styles(self, tree_node: T) -> NodeFormatter:
+        """
+        Build and return a NodeFormatter for the given tree node (apply trim, newline literal, background color, border).
+        """
+        contents = str(self.get_node_val(tree_node))
+        if self.show_newline:
+            contents = contents.replace("\n", self.newline_literal)
+        if self.trim != -1:
+            contents = trim_text(contents, self.trim, self.trim_symbol)
+        node = NodeFormatter.from_string(contents)
+        if self.border:
+            node.add_border()
+        if self.color:
+            node.color_bg(self.color, add_space=not self.border)
+        return node

pydsa/adj.py

@@ -0,0 +1,166 @@
+from collections import defaultdict
+from heapq import heappop, heappush
+from math import inf
+from typing import Any, Deque, Iterator, List, Optional, Set, Tuple
+
+from .grid import _holds, table
+
+
+def adjacency(
+    edges: List[Any],
+    n: Optional[int] = None,
+    reverse: bool = False,
+    directed: bool = True,
+    weighted: bool = False,
+) -> Any:
+    """Adjacency from an edge list. Each edge is [a, b] or, with weighted,
+    [a, b, w]. Unweighted returns a dict of lists in edge order; weighted a
+    dict of dicts, adj[a][b] = w. With n, nodes 0 to n - 1 are all keys,
+    isolated ones with an empty list. reverse reads each edge as b to a.
+    directed=False adds both directions."""
+    adj: Any = defaultdict(dict) if weighted else defaultdict(list)
+    for c in range(n or 0):
+        adj[c]
+    for e in edges:
+        a, b = e[:2]
+        if reverse:
+            a, b = b, a
+        if weighted:
+            adj[a][b] = e[2]
+            if not directed:
+                adj[b][a] = e[2]
+        else:
+            adj[a].append(b)
+            if not directed:
+                adj[b].append(a)
+    return adj
+
+
+def indegrees(
+    edges: List[Any],
+    n: Optional[int] = None,
+    reverse: bool = False,
+    directed: bool = True,
+    type: Any = defaultdict,
+) -> Any:
+    """In-degree of every node from an edge list, each edge [a, b] counting
+    one into b. Default is a defaultdict(int), any node reading 0; with n,
+    nodes 0 to n - 1 are all keys. type=list needs n and returns a plain
+    list. reverse reads each edge as b to a. directed=False counts the edge
+    into a as well, so the result is the plain degree of every node."""
+    indeg: Any
+    if type is list:
+        if n is None:
+            raise ValueError("type=list needs n")
+        indeg = table(n)
+    else:
+        indeg = defaultdict(int)
+        for c in range(n or 0):
+            indeg[c]
+    for e in edges:
+        a, b = e[:2]
+        if reverse:
+            a, b = b, a
+        indeg[b] += 1
+        if not directed:
+            indeg[a] += 1
+    return indeg
+
+
+def levels(
+    q: Deque[Any],
+    grid: Optional[Any] = None,
+    seen: Optional[Set[Any]] = None,
+    grouped: bool = False,
+    eq: Any = None,
+    lt: Any = None,
+    lte: Any = None,
+    gt: Any = None,
+    gte: Any = None,
+) -> Iterator[Tuple[int, Any]]:
+    """Level-order BFS over a deque the caller keeps pushing onto.
+
+    Yields (d, item) for every item popped, where d is the level the item
+    was pushed at, starting from 0 for the items already in q. The caller
+    appends the next level's items to q inside the loop body. With grouped=True
+    yields (d, items) once per level, items being the whole level as a list.
+
+    Every popped item is checked before it is yielded. With eq, lt, lte, gt or
+    gte, an item whose value fails one of them is dropped; the value is
+    grid[item[0]][item[1]] when grid is given, else the item itself. With
+    seen, an item already in seen is dropped and a kept item is added to it,
+    so the caller can push without checking.
+    """
+
+    def keep(x: Any) -> bool:
+        v = x if grid is None else grid[x[0]][x[1]]
+        if not _holds(v, eq, lt, lte, gt, gte) or (seen is not None and x in seen):
+            return False
+        if seen is not None:
+            seen.add(x)
+        return True
+
+    d = 0
+    while q:
+        popped = (q.popleft() for _ in range(len(q)))
+        if grouped:
+            level = [x for x in popped if keep(x)]
+            if level:
+                yield d, level
+        else:
+            for x in popped:
+                if keep(x):
+                    yield d, x
+        d += 1
+
+
+def components(vertices, edges):
+    """The connected components of a graph given as its vertices and a
+    function edges(u) listing u's neighbours, each as a list of vertices."""
+    left, out = set(vertices), []
+    while left:
+        stack, comp = [left.pop()], []
+        while stack:
+            u = stack.pop()
+            comp.append(u)
+            for v in edges(u):
+                if v in left:
+                    left.remove(v)
+                    stack.append(v)
+        out.append(comp)
+    return out
+
+
+class Graph:
+    """Vertices and weighted adjacency lists, adj[u] = [(v, w), ...]. An
+    edge (u, v) weighs 1; an edge (u, v, w) weighs w."""
+
+    def __init__(self, vertices, edges, directed=False):
+        self.vertices = list(vertices)
+        self.adj = {u: [] for u in self.vertices}
+        for e in edges:
+            u, v, w = e if len(e) == 3 else (*e, 1)
+            self.adj[u].append((v, w))
+            if not directed:
+                self.adj[v].append((u, w))
+
+
+def graph(vertices, edges, directed=False):
+    """A Graph of these vertices and edges."""
+    return Graph(vertices, edges, directed)
+
+
+def dijkstra(g, src):
+    """Shortest distance from src to every vertex of g, inf when unreachable."""
+    dist = {u: inf for u in g.vertices}
+    dist[src] = 0
+    pq = [(0, src)]
+    while pq:
+        d, u = heappop(pq)
+        if d > dist[u]:
+            continue
+        for v, w in g.adj[u]:
+            if d + w < dist[v]:
+                dist[v] = d + w
+                heappush(pq, (d + w, v))
+    return dist

pydsa/arith.py

@@ -0,0 +1,19 @@
+"""Integer arithmetic helpers."""
+
+from itertools import zip_longest
+from typing import Any, List, Sequence
+
+
+def ceil_div(a: int, b: int) -> int:
+    """a / b rounded up, for a >= 0 and b > 0."""
+    if b <= 0:
+        raise ValueError("Denominator b must be positive.")
+    if a < 0:
+        raise ValueError("Numerator a must be non-negative.")
+    return (a + b - 1) // b
+
+
+def batched(s: Sequence[Any], n: int = 1) -> List[Any]:
+    """s cut into pieces of n; the last piece holds what is left."""
+    r = list(range(0, len(s), n))
+    return [s[a:b] for a, b in zip_longest(r, r[1:])]

pydsa/bst.py

@@ -0,0 +1,78 @@
+import random
+from collections import deque
+from typing import List, Optional
+
+from .nodes import TreeNode
+from .tree import draw_tree
+
+
+def insert(root: Optional[TreeNode], val: int) -> TreeNode:
+    """Insert a value into the BST and return the root."""
+    if not root:
+        return TreeNode(val)
+    if val < root.val:
+        root.left = insert(root.left, val)
+    elif val > root.val:
+        root.right = insert(root.right, val)
+    # If val == root.val, ignore (no duplicates in this BST)
+    return root
+
+
+def generate_random_bst(n: int, seed: Optional[int] = None) -> Optional[TreeNode]:
+    """Generate a random BST with values 1..n inserted in random order."""
+    if n <= 0:
+        return None
+    if seed:
+        random.seed(seed)
+    values = list(range(1, n + 1))
+    random.shuffle(values)
+    root = None
+    for val in values:
+        root = insert(root, val)
+    return root
+
+
+def tree_to_list(root: Optional[TreeNode]) -> List[Optional[int]]:
+    """Convert BST to list using level-order traversal."""
+    if not root:
+        return []
+    result: List[Optional[int]] = []
+    queue = deque([root])
+    while queue:
+        node = queue.popleft()
+        if node is not None:
+            result.append(node.val)
+            queue.append(node.left)
+            queue.append(node.right)
+        else:
+            result.append(None)
+    # Trim trailing Nones
+    while result and result[-1] is None:
+        result.pop()
+    return result
+
+
+def is_valid_bst(root: Optional[TreeNode]) -> bool:
+    """Check if the tree is a valid BST using inorder traversal."""
+
+    def inorder(node):
+        if not node:
+            return []
+        return inorder(node.left) + [node.val] + inorder(node.right)
+
+    vals = inorder(root)
+    return all(vals[i] < vals[i + 1] for i in range(len(vals) - 1))
+
+
+def generate_and_print_random_bst(
+    n: int, seed=None, verbose=True
+) -> Optional[TreeNode]:
+    root = generate_random_bst(n, seed)
+    valid = is_valid_bst(root)
+    assert valid
+    if verbose:
+        draw_tree(root)
+        lst = tree_to_list(root)
+        print(lst)
+        print("Valid BST:", valid)
+    return root