Visualization Tools

class Draw:
    """
    A base class for drawing various data structures.
    
    This class provides basic functionalities for rendering, saving, and displaying
    visual representations of data structures.
    """

def set_figsize(self, figsize):
    """
    Set the figure size for the plot.
    
    Args:
        figsize (tuple): A tuple representing the figure size (width, height).
    """

def draw(self, **kwargs):
    """
    Display the rendered plot.

    Args:
        **kwargs: Additional keyword arguments.
    """

def save(self, filename, **kwargs):
    """
    Save the rendered plot to a file.
    
    Args:
        filename (str): The name of the file to save the plot to.
        **kwargs: Additional keyword arguments.
    """

class TreeDraw(Draw):
    """
    A class for drawing a tree structure using the NetworkX library.

    This class extends the `Draw` class to visualize tree structures. It organizes the nodes
    in a hierarchical tree layout and provides options for customization through the `render` method.

    Attributes:
        tree (Tree): The tree structure to be drawn.

    Usage Example:
        t = Tree(root_node)  # Define your tree structure with a root node
        td = TreeDraw(t)
        td.draw()
    """

def __init__(self, tree: Tree):
    """ 
    Initializes the TreeDraw object.

    Args:
        tree (Tree): The tree structure to be drawn.
    """

class HeapDraw(Draw):
    """
    A class for drawing a heap structure using the NetworkX library.

    This class extends the `Draw` class to visualize heap structures, such as binary heaps or min-heaps.

    Attributes:
        heap (Heap): The heap structure to be drawn.

    Usage Example:
        h = MinHeap()  # Define your heap, e.g., MinHeap or Heap
        hd = HeapDraw(h)
        hd.draw()
    """

def __init__(self, heap: Heap, **kwargs):
    """
    Initializes the HeapDraw object.

    Args:
        heap (Heap): The heap structure to be drawn.
        **kwargs: Additional keyword arguments passed to the parent `Draw` class.
    """

class TrieDraw(Draw):
    """
    A class for drawing a Trie structure using the NetworkX library.

    This class extends the `Draw` class to visualize Trie structures, commonly used for storing strings
    or prefix trees. It provides methods to convert the Trie into a networkx graph, arrange nodes
    hierarchically, and render the visualization using Matplotlib.

    Attributes:
        trie (Trie): The Trie structure to be drawn.

    Usage Example:
        trie = Trie()  # Initialize your Trie and populate it with words
        trd = TrieDraw(trie)
        trd.draw()
    """

def __init__(self, trie: Trie, **kwargs):
    """
    Initializes the TrieDraw object.

    Args:
        trie (Trie): The Trie structure to be drawn.
        **kwargs: Additional keyword arguments passed to the parent `Draw` class.
    """

def render_rectangle(self, **kwargs):
    """
    Renders the Trie as a hierarchical graph using Matplotlib. Not to be called directly. Call draw() instead.

    This method uses the hierarchical positions of the nodes to render the Trie
    as a directed graph. Nodes are drawn as rectangles, and edges represent the transitions
    between prefixes.

    Returns:
        matplotlib.pyplot: The Matplotlib plot object for further customization or display.
    """

class GraphDraw(Draw):
    """
    A class for drawing graphs using the NetworkX library.

    This class extends the `Draw` class to visualize graphs. It supports both directed 
    and undirected graphs, as well as weighted and unweighted graphs. Additionally, 
    it provides an option to display the Minimum Spanning Tree (MST) of the graph.
    
    If directed or weighted parameters are not provided, they will be inferred from the graph type.

    Attributes:
        graph: The graph to be drawn
        directed (bool): Specifies if the graph is directed. Defaults to None
        weighted (bool): Specifies if the graph has weighted edges. Defaults to None

    Usage Example:
        gd = GraphDraw(g) # g is a Graph type (AdjacencyMatrixGraph, AdjacencyMatrixWeightedGraph, AdjacencyListWeightedGraph, AdjacencyListGraph)
        gd.draw()
    """

def __init__(self, graph, directed=None, weighted=None):
    """
    Initializes the GraphDraw object.
    """

def render(self, pos=None, show_mst=False, mst_only=False, **kwargs):
    """
    Renders the graph using Matplotlib. Not to be called directly. Call draw() instead.
    """