the-maze-py 0.1.0__tar.gz

the_maze_py-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2026 CaptaininjaGuy
+
+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.

the_maze_py-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: the-maze-py
+Version: 0.1.0
+Summary: A package that generates mazes
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Captaininja-Guy/mazepy
+Keywords: maze
+Classifier: Programming Language :: Python :: 3
+Classifier: Natural Language :: English
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.4.6
+Requires-Dist: pyvista>=0.48.4
+Requires-Dist: matplotlib>=3.10.9
+Requires-Dist: pillow>=12.2.0
+Dynamic: license-file
+
+mazepy
+=======
+
+A maze library based off of the book [Mazes for Programmers](https://pragprog.com/titles/jbmaze/mazes-for-programmers/) by Jamis Buck but with more stuff.
+
+Installation
+```bash
+pip install maze-py
+```
+
+Maze Shapes Supported
+---------------------
+#### 2D
+* Rectangular
+* Polar (Circular)
+* Hexagonal
+* Triangular
+* Arbitrary shapes with masking
+#### 3D
+* Layers (Grid 3D)
+* Cylindrical
+* Spherical
+* Cube
+* Toroidal
+* Möbius Strip
+
+Generation Algorithms Supported
+-------------------------------
+* Aldous Broder
+* Binary Tree (not triangular)
+* Ellers (not triangular)
+* Fractal Tesselation (only rectangualar)
+* Growing Tree
+* Hunt and Kill
+* Kruskals (not polar, haxagonal, or triangular)
+* Origin Shift
+* Prims (Simplified, True, Modified)
+* Recursive Backtrack (DFS)
+* Recursive Division (only Rectangular)
+* Sidewinder
+* Wilsons
+
+Other Features
+--------------
+* Printing rectangular mazes
+* Generating pngs of mazes
+* Color grids based on distance
+* Viewing 3d grids in 3d
+* Animations of maze creation and filling with color gradient
+
+
+Examples
+========
+Showing a colored maze
+----------------------
+```python
+import mazepy as mp
+
+grid = mp.grids.ColoredGrid(10,10, base='red', end='blue')
+mp.algorithms.Ellers(grid)
+grid.distances = grid[5, 5].distances()   # Set starting cell (this is required)
+grid.show()
+```
+
+<img src="https://raw.githubusercontent.com/Captaininja-Guy/mazepy/refs/heads/main/pictures/colored.png" width="400"/>
+
+Mazes of different shapes
+-------------------------
+```python
+import mazepy as mp
+
+grid = mp.grids.PolarGrid(10)
+mp.algorithms.RecursiveBacktrack(grid)
+grid.show()
+```
+<img src="https://raw.githubusercontent.com/Captaininja-Guy/mazepy/refs/heads/main/pictures/polar.png" width="400"/>

the_maze_py-0.1.0/README.md

@@ -0,0 +1,76 @@
+mazepy
+=======
+
+A maze library based off of the book [Mazes for Programmers](https://pragprog.com/titles/jbmaze/mazes-for-programmers/) by Jamis Buck but with more stuff.
+
+Installation
+```bash
+pip install maze-py
+```
+
+Maze Shapes Supported
+---------------------
+#### 2D
+* Rectangular
+* Polar (Circular)
+* Hexagonal
+* Triangular
+* Arbitrary shapes with masking
+#### 3D
+* Layers (Grid 3D)
+* Cylindrical
+* Spherical
+* Cube
+* Toroidal
+* Möbius Strip
+
+Generation Algorithms Supported
+-------------------------------
+* Aldous Broder
+* Binary Tree (not triangular)
+* Ellers (not triangular)
+* Fractal Tesselation (only rectangualar)
+* Growing Tree
+* Hunt and Kill
+* Kruskals (not polar, haxagonal, or triangular)
+* Origin Shift
+* Prims (Simplified, True, Modified)
+* Recursive Backtrack (DFS)
+* Recursive Division (only Rectangular)
+* Sidewinder
+* Wilsons
+
+Other Features
+--------------
+* Printing rectangular mazes
+* Generating pngs of mazes
+* Color grids based on distance
+* Viewing 3d grids in 3d
+* Animations of maze creation and filling with color gradient
+
+
+Examples
+========
+Showing a colored maze
+----------------------
+```python
+import mazepy as mp
+
+grid = mp.grids.ColoredGrid(10,10, base='red', end='blue')
+mp.algorithms.Ellers(grid)
+grid.distances = grid[5, 5].distances()   # Set starting cell (this is required)
+grid.show()
+```
+
+<img src="https://raw.githubusercontent.com/Captaininja-Guy/mazepy/refs/heads/main/pictures/colored.png" width="400"/>
+
+Mazes of different shapes
+-------------------------
+```python
+import mazepy as mp
+
+grid = mp.grids.PolarGrid(10)
+mp.algorithms.RecursiveBacktrack(grid)
+grid.show()
+```
+<img src="https://raw.githubusercontent.com/Captaininja-Guy/mazepy/refs/heads/main/pictures/polar.png" width="400"/>

the_maze_py-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "the-maze-py"
+version = "0.1.0"
+description = "A package that generates mazes"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "numpy>=2.4.6",
+    "pyvista>=0.48.4",
+    "matplotlib>=3.10.9",
+    "pillow>=12.2.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Natural Language :: English",
+]
+keywords = ["maze"]
+
+
+[project.urls]
+Homepage = "https://github.com/Captaininja-Guy/mazepy"
+
+[tool.setuptools.packages.find]
+where = ["src"]

the_maze_py-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

the_maze_py-0.1.0/src/mazepy/__init__.py

@@ -0,0 +1,14 @@
+from . import grids
+from . import algorithms
+from . import cells
+from .create_animation_2d import play_create_2d
+from .deadends import Deadends
+from .fill_animation_2d import play_fill_2d
+from .longest_path import longest_path
+from .mask import Mask
+from .preconfigure_grid_example import precon_grid_ex
+from .weighted_shortest_path_example import weight_grid_ex
+
+__all__ = ["grids", "algorithms", "cells", "play_create_2d",
+           "Deadends", "play_fill_2d", "longest_path",
+           "Mask", "precon_grid_ex", "weight_grid_ex"]

the_maze_py-0.1.0/src/mazepy/algorithms/__init__.py

@@ -0,0 +1,87 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .aldous_broder import AldousBroder
+    from .binary_tree import BinaryTree
+    from .ellers import Ellers
+    from .fractal_tesselation import FractalTessalation
+    from .growing_tree import GrowingTree
+    from .hunt_and_kill import HuntandKill
+    from .kruskals import Kruskals
+    from .origin_shift import OriginShift
+    from .prims import Prims, TruePrims, ModifiedPrims, SimplifiedPrims
+    from .recursive_backtrack import RecursiveBacktrack
+    from .recursive_division import RecursiveDivision
+    from .sidewinder import Sidewinder
+    from .wilsons import Wilsons
+
+
+def __getattr__(name):
+    if name == "AldousBroder":
+        from .aldous_broder import AldousBroder
+        return AldousBroder
+    if name == "BinaryTree":
+        from .binary_tree import BinaryTree
+        return BinaryTree
+    if name == "Ellers":
+        from .ellers import Ellers
+        return Ellers
+    if name == "FractalTessalation":
+        from .fractal_tesselation import FractalTessalation
+        return FractalTessalation
+    if name == "GrowingTree":
+        from .growing_tree import GrowingTree
+        return GrowingTree
+    if name == "HuntandKill":
+        from .hunt_and_kill import HuntandKill
+        return HuntandKill
+    if name == "Kruskals":
+        from .kruskals import Kruskals
+        return Kruskals
+    if name == "OriginShift":
+        from .origin_shift import OriginShift
+        return OriginShift
+    if name == "Prims":
+        from .prims import Prims
+        return Prims
+    if name == "TruePrims":
+        from .prims import TruePrims
+        return TruePrims
+    if name == "ModifiedPrims":
+        from .prims import ModifiedPrims
+        return ModifiedPrims
+    if name == "SimplifiedPrims":
+        from .prims import SimplifiedPrims
+        return SimplifiedPrims
+    if name == "RecursiveBacktrack":
+        from .recursive_backtrack import RecursiveBacktrack
+        return RecursiveBacktrack
+    if name == "RecursiveDivision":
+        from .recursive_division import RecursiveDivision
+        return RecursiveDivision
+    if name == "Sidewinder":
+        from .sidewinder import Sidewinder
+        return Sidewinder
+    if name == "Wilsons":
+        from .wilsons import Wilsons
+        return Wilsons
+
+    raise AttributeError(name)
+
+
+__all__ = ["AldousBroder",
+           "BinaryTree",
+           "Ellers",
+           "FractalTessalation",
+           "GrowingTree",
+           "HuntandKill",
+           "Kruskals",
+           "OriginShift",
+           "Prims",
+           "TruePrims",
+           "ModifiedPrims",
+           "SimplifiedPrims",
+           "RecursiveBacktrack",
+           "RecursiveDivision",
+           "Sidewinder",
+           "Wilsons"]

the_maze_py-0.1.0/src/mazepy/algorithms/aldous_broder.py

@@ -0,0 +1,32 @@
+import random as rand
+from ..grids.grid import Grid
+
+def AldousBroder(grid: Grid) -> None:
+    '''
+    Performs the AldousBroder algorithm on a given Grid in place.
+    Any type of grid can be used
+
+    Parameters:
+        grid (Grid)
+    
+    Returns:
+        None, the grid is modified in place
+
+    Example:
+        import mazepy as mp
+
+        grid = mp.grids.Grid(20,20)
+        mp.algorithms.AldousBroder(grid)
+        grid.show()
+    '''
+    cell = grid.random_cell()
+    unvisited = grid.size - 1
+
+    while unvisited > 0:
+        neighbor = rand.choice(cell.neighbors())
+
+        if not neighbor.links():
+            cell.link(neighbor)
+            unvisited -= 1
+        
+        cell = neighbor

the_maze_py-0.1.0/src/mazepy/algorithms/binary_tree.py

@@ -0,0 +1,65 @@
+import random as rand
+from ..grids.grid import Grid
+from ..grid_not_supported_exception import GridNotSupportedException
+import warnings
+
+
+
+def BinaryTree(grid: Grid) -> None:
+    '''
+    Performs Binary Tree algorithm on a given Grid in place
+    Most non-triangle Grids can be used with satisfactory results
+
+    Parameters:
+        grid (Grid)
+
+    Returns:
+        None the grid is modified in place
+
+    Warnings:
+        RuntimeWarning Binary tree cannot produce weaving on weaved grids
+    
+    Errors:
+        Throws GridNotSupportedException when given a TriangleGrid
+
+    Example:
+        import mazepy as mp
+
+        grid = mp.grids.Grid(20,20)
+        mp.algorithms.BinaryTree(grid)
+        grid.show()
+    '''
+
+    if grid.type_of_grid == 'triangle':
+        raise GridNotSupportedException('TriangleGrid not compatible with Binary Tree')
+    if grid.type_of_grid == 'weave': # Warning for Weaved Grids as weaving will not occur
+        warnings.warn('Binary Tree will NOT produce weaved grid')
+
+    _hex, polar, three_d = grid.type_of_grid == 'hex', grid.type_of_grid == 'polar', grid.type_of_grid == '3d'
+    
+    for cell in grid.each_cell():
+        neighbors = []
+        if cell.north:
+            neighbors.append(cell.north)
+        if cell.east:
+            neighbors.append(cell.east)
+        if _hex: # HexGrid support
+            if cell.northeast:
+                neighbors.append(cell.northeast)
+            elif cell.southeast:
+                neighbors.append(cell.southeast)
+        elif polar: # Polar support
+            if cell is grid[0,0]:
+                neighbors = cell.outward[0:2]
+            else:
+                if cell.column != 0:
+                    neighbors.append(cell.ccw)
+                if cell.outward:
+                    neighbors.append(cell.outward[0])
+                    
+        if three_d and cell.up:
+            neighbors.append(cell.up)
+
+        if len(neighbors) > 0:
+            neighbor = rand.choice(neighbors)
+            cell.link(neighbor)

the_maze_py-0.1.0/src/mazepy/algorithms/ellers.py

@@ -0,0 +1,143 @@
+from ..grids.grid import Grid
+from ..cells.cell import Cell
+import random as rand
+from ..grid_not_supported_exception import GridNotSupportedException
+import warnings
+
+class _RowState:
+    def __init__(self, starting_set: int = 0):
+        self.cells_in_set = {}
+        self.set_for_cell = []
+        self.next_set = starting_set
+
+    def record(self, _set: int, cell: Cell) -> None:
+        while cell.column >= len(self.set_for_cell):
+            self.set_for_cell.append(None)
+
+        self.set_for_cell[cell.column] = _set
+        self.cells_in_set.setdefault(_set, [])
+        self.cells_in_set[_set].append(cell)
+    
+    def set_for(self, cell: Cell) -> int:
+        if cell.column >= len(self.set_for_cell) or self.set_for_cell[cell.column] is None:
+            self.record(self.next_set, cell)
+            self.next_set += 1
+        
+        return self.set_for_cell[cell.column]
+    
+    def merge(self, winner: int, loser: int) -> None:
+        for cell in self.cells_in_set[loser]:
+            self.set_for_cell[cell.column] = winner
+            self.cells_in_set[winner].append(cell)
+        
+        del self.cells_in_set[loser]
+    
+    def _next(self):
+        return _RowState(self.next_set)
+    
+    def each_set(self):
+        for set_, cells in self.cells_in_set.items():
+            yield set_, cells
+
+def Ellers(grid: Grid) -> None:
+    '''
+    Performs Ellers algorithm on a given Grid in place.
+    Triangle grids not supported 3d and cube Grids are not perfect
+
+    Parameters:
+        grid (Grid)
+    
+    Returns:
+        None, the grid is modified in place
+
+    Errors:
+        GridNotSupportedException if Grid is triangular
+    
+    Warnings:
+        RuntimeWarning Ellers produced non-perfect mazes on 3d and cube grids
+
+    Example:
+        import mazepy as mp
+
+        grid = mp.grids.Grid(20,20)
+        mp.algorithms.Ellers(grid)
+        grid.show()
+    '''
+
+    if grid.type_of_grid == 'triangle':
+        raise GridNotSupportedException('Triangle Grids not compatible with Ellers')
+    _hex = grid.type_of_grid == 'hex'
+    polar = grid.type_of_grid == 'polar'
+    if threed := grid.type_of_grid == '3d':
+        warnings.warn('Ellers on 3d grids produces seperate 2d grids with no up/down connections', RuntimeWarning)
+    if grid.type_of_grid == 'cube':
+        warnings.warn('Ellers on a cube grid may not produce a perfect maze', RuntimeWarning)
+
+    if threed:
+        each_level = grid.each_level()
+    else:
+        each_level = [grid]
+    
+    for level in each_level:
+        row_state = _RowState()
+        if threed:
+            rows = level
+        else:
+            rows = level.each_row()
+
+        for row in rows:
+            for cell in row:
+                if not _hex and not polar and not cell.west: continue
+                elif _hex and cell.column%2 == 0 and not cell.northwest: continue
+                elif polar and len(row) == 1: continue
+
+
+                _set = row_state.set_for(cell)
+                if not _hex and not polar:
+                    prior_set = row_state.set_for(cell.west)
+                elif _hex:
+                    prior_set = row_state.set_for(cell.southwest) if cell.column%2 == 1 else row_state.set_for(cell.northwest)
+                elif polar:
+                    prior_set = row_state.set_for(cell.ccw)
+
+
+                if not polar and _set != prior_set and (cell.south is None or rand.randrange(2) == 0):
+                    if not _hex and not polar:
+                        cell.link(cell.west)
+                    else:
+                        if cell.column % 2 == 1:
+                            cell.link(cell.southwest)
+                        else:
+                            cell.link(cell.northwest)
+                    row_state.merge(prior_set, _set)
+
+                elif polar and _set != prior_set and (not cell.outward or rand.randrange(2) == 0):
+                    cell.link(cell.ccw)
+                    row_state.merge(prior_set, _set)
+
+            if row[0].south:
+                next_row = row_state._next()
+
+                for _, _list in row_state.each_set():
+                    list2 = _list.copy()
+                    rand.shuffle(list2)
+
+                    for index, cell in enumerate(list2):
+                        if index == 0 or rand.randrange(3) == 0:
+                            cell.link(cell.south)
+                            next_row.record(row_state.set_for(cell), cell.south)
+
+            elif polar and row[0].outward:
+                next_row = row_state._next()
+
+                for _, _list in row_state.each_set():
+                    list2 = _list.copy()
+                    rand.shuffle(list2)
+                    for index, cell in enumerate(list2):
+                        if index == 0 or rand.randrange(3) == 0:
+                            cell2 = cell.outward[rand.randrange(len(cell.outward))]
+                            cell.link(cell2)
+                            next_row.record(row_state.set_for(cell), cell2)
+            
+
+            row_state = next_row

the_maze_py-0.1.0/src/mazepy/algorithms/fractal_tesselation.py

@@ -0,0 +1,74 @@
+from ..grids.grid import Grid
+from ..grids.colored_grid import ColoredGrid
+import random as rand
+from itertools import product
+from ..grid_not_supported_exception import GridNotSupportedException
+
+def FractalTessalation(grid: Grid|None = None, times: int = 4, base: tuple[int]|str|None = None, end: tuple[int]|str|None = None) -> ColoredGrid|None:
+    '''
+    Performs fractal tesselation on an existing Grid or generates a Grid
+
+    Parameters:
+        grid (optional Grid)
+        times (optional int) = 4, how many iterations to perform
+        base (optional tuple[int]|str) PIL/pillow valid color for return grid
+        end (optional tuple[int]|str) PIL/pillow valid color for return grid
+
+    Returns:
+        ColoredGrid
+    
+    Errors:
+        GridNotSupportedException if grid is not rectangular
+    '''
+    if grid is None:
+        grid = Grid(1, 1)
+    elif hasattr(grid, 'base'):
+        base = grid.base
+        end = grid.end
+    
+    if grid.type_of_grid != 'regular':
+        raise GridNotSupportedException('Non-rectangular grids not compatible with Fractal Tessalation')
+
+    for i in range(times):
+        if base is not None and i == times - 1:
+            grid_new = ColoredGrid(grid.rows*2, grid.columns*2, base=base, end=end)
+        else:
+            grid_new = Grid(grid.rows*2, grid.columns*2)
+        for cell in grid.each_cell():
+            new_row, new_column = cell.row+grid.rows, cell.column+grid.columns
+            for row, col in product((cell.row, new_row), (cell.column, new_column)):
+                links = cell.links()
+                cell2 = grid_new[row, col]
+                if cell.north in links:
+                    cell2.link(cell2.north)
+                if cell.east in links:
+                    cell2.link(cell2.east)
+                if cell.south in links:
+                    cell2.link(cell2.south)
+                if cell.west in links:
+                    cell2.link(cell2.west)
+        
+        exc_path = rand.randrange(2)
+        if exc_path == 0:
+            num1, num2, num3 = rand.randrange(grid.columns), rand.randrange(grid.columns), rand.randrange(grid.rows)
+            cell1 = grid_new[grid.rows, num1]
+            cell2 = grid_new[grid.rows, grid.columns+num2]
+            cell3 = grid_new[grid.rows*rand.randrange(2) + num3, grid.columns]
+
+            cell1.link(cell1.north)
+            cell2.link(cell2.north)
+            cell3.link(cell3.west)
+        else:
+            num1, num2, num3 = rand.randrange(grid.columns), rand.randrange(grid.rows), rand.randrange(grid.rows)
+            cell1 = grid_new[grid.rows, num1 + grid.columns*rand.randrange(2)]
+            cell2 = grid_new[num2, grid.columns]
+            cell3 = grid_new[grid.rows + num3, grid.columns]
+
+            cell1.link(cell1.north)
+            cell2.link(cell2.west)
+            cell3.link(cell3.west)
+        
+        grid = grid_new
+    
+    return grid_new
+        

the_maze_py-0.1.0/src/mazepy/algorithms/growing_tree.py

@@ -0,0 +1,40 @@
+from ..grids.grid import Grid
+from ..cells.cell import Cell
+import random as rand
+from typing import Callable
+
+def GrowingTree(grid: Grid, func: Callable = lambda x: rand.choice(x), start_at: Cell|None = None) -> None:
+    '''
+    Performs the GrowingTree algorithm on a given Grid in place.
+    Any type of grid can be used
+
+    Parameters:
+        grid (Grid)
+        func (optional Callable) = lambda x: rand.choice(x), function to select next cell from visited list (list -> element from it)
+        start_at (optional Cell) = grid.random_cell(), which cell to start algorithm at
+    
+    Returns:
+        None, the grid is modified in place
+
+    Example:
+        import mazepy as mp
+
+        grid = mp.grids.Grid(20,20)
+        mp.algorithms.GrowingGree(grid)
+        grid.show()
+    '''
+    if start_at is None:
+        start_at = grid.random_cell()
+
+    active = [start_at]
+
+    while active:
+        cell = func(active) # func takes a list and returns an element of it
+        availible_neighbors = [c for c in cell.neighbors() if not c.links()]
+
+        if availible_neighbors:
+            neighbor = rand.choice(availible_neighbors)
+            cell.link(neighbor)
+            active.append(neighbor)
+        else:
+            active.remove(cell)