Python visualization

pip install matplotlib networkx

import matplotlib.pyplot as plt
import networkx as nx

def draw_directed_graph(edges, pos=None, node_size=300, font_size=10, arrow_size=20, ax=None):
    """
    Draws a directed graph using Matplotlib and NetworkX.

    Args:
        edges (list of tuples): A list of tuples, where each tuple represents
                                 a directed edge (source, target).
        pos (dict, optional): A dictionary with nodes as keys and positions
                              as values. If None, a spring layout will be used.
        node_size (int, optional): The size of the nodes. Defaults to 300.
        font_size (int, optional): The font size for node labels. Defaults to 10.
        arrow_size (int, optional): The size of the arrows for directed edges.
                                    Defaults to 20.
        ax (matplotlib.axes.Axes, optional): The Matplotlib axes object to draw
                                             on. If None, a new figure and axes
                                             will be created.
    """
    # Create a directed graph object
    G = nx.DiGraph()

    # Add edges to the graph
    G.add_edges_from(edges)

    # If no positions are provided, compute a layout
    if pos is None:
        pos = nx.spring_layout(G) # You can choose other layouts like nx.circular_layout(G), nx.shell_layout(G), etc.

    # If no axes object is provided, create a new figure and axes
    if ax is None:
        fig, ax = plt.subplots()

    # Draw the nodes
    nx.draw_networkx_nodes(G, pos, node_size=node_size, ax=ax, node_color='skyblue', alpha=0.9)

    # Draw the edges
    nx.draw_networkx_edges(G, pos, arrowstyle='-|>', arrowsize=arrow_size, edge_color='gray', width=1.5, ax=ax)

    # Draw the labels (node names)
    nx.draw_networkx_labels(G, pos, font_size=font_size, ax=ax)

    # Set plot title and remove axes
    ax.set_title("Directed Graph Example")
    ax.axis('off')

    # Display the plot if no axes object was provided
    if ax == plt.gca(): # Check if the current axes is the one we created
        plt.show()

# --- Example Usage ---

if __name__ == "__main__":
    # Define the edges for the directed graph
    # Each tuple (source, target) represents a directed edge from source to target
    example_edges = [
        ('A', 'B'),
        ('A', 'C'),
        ('B', 'D'),
        ('C', 'D'),
        ('D', 'E'),
        ('E', 'A'),
        ('C', 'E')
    ]

    # --- Basic Example ---
    print("Drawing basic directed graph...")
    draw_directed_graph(example_edges)

    # --- Example with Custom Layout and Styling ---
    print("\nDrawing directed graph with custom layout and styling...")
    # You can pre-define node positions if you want a specific arrangement
    custom_pos = {
        'A': (0, 0),
        'B': (1, 1),
        'C': (1, -1),
        'D': (2, 0),
        'E': (3, 0)
    }
    plt.figure(figsize=(8, 6)) # Create a new figure for this example
    draw_directed_graph(
        example_edges,
        pos=custom_pos,
        node_size=500,
        font_size=12,
        arrow_size=30,
        ax=plt.gca() # Draw on the current figure's axes
    )
    plt.title("Directed Graph with Custom Layout and Styling")
    plt.show()

    # --- Example with a Circular Layout ---
    print("\nDrawing directed graph with circular layout...")
    plt.figure(figsize=(6, 6))
    draw_directed_graph(
        example_edges,
        pos=nx.circular_layout(nx.DiGraph(example_edges)), # Compute circular layout
        node_size=400,
        font_size=11,
        arrow_size=25,
        ax=plt.gca()
    )
    plt.title("Directed Graph with Circular Layout")
    plt.show()