pizza-lib 0.1.0__tar.gz

pizza_lib-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,64 @@
+# 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/pizza_lib.egg-info/PKG-INFO

@@ -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/pizza_lib.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+LICENSE
+README.md
+pyproject.toml
+pizza_lib.egg-info/PKG-INFO
+pizza_lib.egg-info/SOURCES.txt
+pizza_lib.egg-info/dependency_links.txt
+pizza_lib.egg-info/requires.txt
+pizza_lib.egg-info/top_level.txt
+pydsa/__init__.py
+pydsa/_treeformat.py
+pydsa/adj.py
+pydsa/arith.py
+pydsa/bst.py
+pydsa/combo.py
+pydsa/counting.py
+pydsa/digits.py
+pydsa/generators.py
+pydsa/graphs.py
+pydsa/grid.py
+pydsa/heaps.py
+pydsa/linked.py
+pydsa/nodes.py
+pydsa/search.py
+pydsa/seq.py
+pydsa/tree.py
+tests/test_adj.py
+tests/test_combo.py
+tests/test_counting.py
+tests/test_digits.py
+tests/test_graphs.py
+tests/test_grid.py
+tests/test_search.py
+tests/test_seq.py
+tests/test_tree.py

pizza_lib-0.1.0/pizza_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pizza_lib-0.1.0/pizza_lib.egg-info/requires.txt

@@ -0,0 +1,9 @@
+
+[draw]
+rich
+colorama
+PrettyPrintTree
+graphviz
+
+[test]
+pytest

pizza_lib-0.1.0/pizza_lib.egg-info/top_level.txt

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

pizza_lib-0.1.0/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"

pizza_lib-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