job-shop-lib 0.5.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

job_shop_lib/visualization/agent_task_graph.py

@@ -1,257 +0,0 @@
-"""Contains functions to plot the agent-task graph of a job shop instance.
-
-The agent-task graph was introduced by Junyoung Park et al. (2021).
-In contrast to the disjunctive graph, instead of connecting operations that
-share the same resources directly by disjunctive edges, operation nodes are
-connected with machine ones. All machine nodes are connected between them, and
-all operation nodes from the same job are connected by non-directed edges too.
-
-See: job_shop_lib.graphs.build_agent_task_graph module for more information.
-"""
-
-from typing import Optional
-
-import matplotlib.pyplot as plt
-import networkx as nx
-
-from job_shop_lib.graphs import NodeType, JobShopGraph, Node
-
-
-def plot_agent_task_graph(
-    job_shop_graph: JobShopGraph,
-    title: Optional[str] = None,
-    figsize: tuple[int, int] = (10, 10),
-    layout: Optional[dict[Node, tuple[float, float]]] = None,
-    color_map_name: str = "tab10",
-    node_size: int = 1000,
-    alpha: float = 0.95,
-    add_legend: bool = False,
-) -> plt.Figure:
-    """Returns a plot of the agent-task graph of the instance.
-
-    Machine and job nodes are represented by squares, and the operation nodes
-    are represented by circles.
-
-    Args:
-        job_shop_graph:
-            The job shop graph instance. It should be already initialized with
-            the instance with a valid agent-task graph representation.
-
-    Returns:
-        The figure of the plot. This figure can be used to save the plot to a
-        file or to show it in a Jupyter notebook.
-    """
-    if title is None:
-        title = (
-            f"Agent-Task Graph Visualization: {job_shop_graph.instance.name}"
-        )
-    # Create a new figure and axis
-    fig, ax = plt.subplots(figsize=figsize)
-    fig.suptitle(title)
-
-    # Create the networkx graph
-    graph = job_shop_graph.graph
-
-    # Create the layout if it was not provided
-    if layout is None:
-        layout = three_columns_layout(job_shop_graph)
-
-    # Define colors and shapes
-    color_map = plt.get_cmap(color_map_name)
-    machine_colors = {
-        machine.machine_id: color_map(i)
-        for i, machine in enumerate(
-            job_shop_graph.nodes_by_type[NodeType.MACHINE]
-        )
-    }
-    node_colors = [
-        _get_node_color(node, machine_colors) for node in job_shop_graph.nodes
-    ]
-    node_shapes = {"machine": "s", "job": "d", "operation": "o", "global": "o"}
-
-    # Draw nodes with different shapes based on their type
-    for node_type, shape in node_shapes.items():
-        current_nodes = [
-            node.node_id
-            for node in job_shop_graph.nodes
-            if node.node_type.name.lower() == node_type
-        ]
-        nx.draw_networkx_nodes(
-            graph,
-            layout,
-            nodelist=current_nodes,
-            node_color=[node_colors[i] for i in current_nodes],
-            node_shape=shape,
-            ax=ax,
-            node_size=node_size,
-            alpha=alpha,
-        )
-
-    # Draw edges
-    nx.draw_networkx_edges(graph, layout, ax=ax)
-
-    node_labels = {
-        node.node_id: _get_node_label(node) for node in job_shop_graph.nodes
-    }
-    nx.draw_networkx_labels(graph, layout, node_labels, ax=ax)
-
-    ax.set_axis_off()
-
-    plt.tight_layout()
-
-    # Add to the legend the meaning of m and d
-    if add_legend:
-        plt.figtext(0, 0.95, "d = duration", wrap=True, fontsize=12)
-    return fig
-
-
-def _get_node_color(
-    node: Node, machine_colors: dict[int, tuple[float, float, float, float]]
-) -> tuple[float, float, float, float] | str:
-    if node.node_type == NodeType.OPERATION:
-        return machine_colors[node.operation.machine_id]
-    if node.node_type == NodeType.MACHINE:
-        return machine_colors[node.machine_id]
-
-    return "lightblue"
-
-
-def _get_node_label(node: Node) -> str:
-    if node.node_type == NodeType.OPERATION:
-        return f"d={node.operation.duration}"
-    if node.node_type == NodeType.MACHINE:
-        return f"M{node.machine_id}"
-    if node.node_type == NodeType.JOB:
-        return f"J{node.job_id}"
-    if node.node_type == NodeType.GLOBAL:
-        return "G"
-
-    raise ValueError(f"Invalid node type: {node.node_type}")
-
-
-def three_columns_layout(
-    job_shop_graph: JobShopGraph,
-    *,
-    leftmost_position: float = 0.1,
-    rightmost_position: float = 0.9,
-    topmost_position: float = 1.0,
-    bottommost_position: float = 0.0,
-) -> dict[Node, tuple[float, float]]:
-    """Returns the layout of the agent-task graph.
-
-    The layout is organized in a grid manner. For example, for a JobShopGraph
-    representing a job shop instance with 2 machines and 3 jobs, the layout
-    would be:
-
-    0:  -       O_11      -
-    1:  -       O_12      J1
-    2:  -       O_13      -
-    3:  M1      O_21      -
-    4:  -       O_22      J2
-    5:  -       O_23      -
-    6:  M2      O_31      -
-    7:  -       O_32      J3
-    8:  -       O_33      -
-    9:  -        -        -
-    10: -        G        -
-    Where M1 and M2 are the machine nodes, J1, J2, and J3 are the job
-    nodes, O_ij are the operation nodes, and G is the global node.
-
-    Args:
-        job_shop_graph:
-            The job shop graph instance. It should be already initialized with
-            the instance with a valid agent-task graph representation.
-        leftmost_position:
-            The center position of the leftmost column of the layout. It should
-            be a float between 0 and 1. The default is 0.1.
-        rightmost_position:
-            The center position of the rightmost column of the layout. It
-            should be a float between 0 and 1. The default is 0.9.
-        topmost_position:
-            The center position of the topmost node of the layout. It should be
-            a float between 0 and 1. The default is 0.9.
-        bottommost_position:
-            The center position of the bottommost node of the layout. It should
-            be a float between 0 and 1. The default is 0.1.
-
-    Returns:
-        A dictionary with the position of each node in the graph. The keys are
-        the node ids, and the values are tuples with the x and y coordinates.
-    """
-
-    x_positions = _get_x_positions(leftmost_position, rightmost_position)
-
-    operation_nodes = job_shop_graph.nodes_by_type[NodeType.OPERATION]
-    machine_nodes = job_shop_graph.nodes_by_type[NodeType.MACHINE]
-    job_nodes = job_shop_graph.nodes_by_type[NodeType.JOB]
-    global_nodes = job_shop_graph.nodes_by_type[NodeType.GLOBAL]
-
-    total_positions = len(operation_nodes) + len(global_nodes) * 2
-    y_spacing = (topmost_position - bottommost_position) / total_positions
-
-    layout: dict[Node, tuple[float, float]] = {}
-
-    machines_spacing_multiplier = len(operation_nodes) // len(machine_nodes)
-    layout.update(
-        _assign_positions_from_top(
-            machine_nodes,
-            x_positions["machine"],
-            topmost_position,
-            y_spacing * machines_spacing_multiplier,
-        )
-    )
-    layout.update(
-        (
-            _assign_positions_from_top(
-                operation_nodes,
-                x_positions["operation"],
-                topmost_position,
-                y_spacing,
-            )
-        )
-    )
-
-    if global_nodes:
-        layout[global_nodes[0]] = (
-            x_positions["operation"],
-            bottommost_position,
-        )
-
-    if job_nodes:
-        job_multiplier = len(operation_nodes) // len(job_nodes)
-        layout.update(
-            _assign_positions_from_top(
-                job_nodes,
-                x_positions["job"],
-                topmost_position,
-                y_spacing * job_multiplier,
-            )
-        )
-    return layout
-
-
-def _get_x_positions(
-    leftmost_position: float, rightmost_position: float
-) -> dict[str, float]:
-    center_position = (
-        leftmost_position + (rightmost_position - leftmost_position) / 2
-    )
-    return {
-        "machine": leftmost_position,
-        "operation": center_position,
-        "job": rightmost_position,
-    }
-
-
-def _assign_positions_from_top(
-    nodes: list[Node],
-    x: float,
-    top: float,
-    y_spacing: float,
-) -> dict[Node, tuple[float, float]]:
-    layout: dict[Node, tuple[float, float]] = {}
-    for i, node in enumerate(nodes):
-        y = top - (i + 1) * y_spacing
-        layout[node] = (x, y)
-
-    return layout

job_shop_lib/visualization/create_gif.py

@@ -1,209 +0,0 @@
-"""Module for creating a GIF of the schedule being built by a
-dispatching rule solver."""
-
-import os
-import pathlib
-import shutil
-from collections.abc import Callable
-
-import imageio
-import matplotlib.pyplot as plt
-from matplotlib.figure import Figure
-
-from job_shop_lib import JobShopInstance, Schedule, Operation
-from job_shop_lib.dispatching import (
-    DispatchingRuleSolver,
-    Dispatcher,
-    HistoryTracker,
-)
-from job_shop_lib.visualization.gantt_chart import plot_gantt_chart
-
-
-# Most of the arguments are optional with default values. There is no way to
-# reduce the number of arguments without losing functionality.
-# pylint: disable=too-many-arguments
-def create_gif(
-    gif_path: str,
-    instance: JobShopInstance,
-    solver: DispatchingRuleSolver,
-    plot_function: (
-        Callable[[Schedule, int, list[Operation] | None, int | None], Figure]
-        | None
-    ) = None,
-    fps: int = 1,
-    remove_frames: bool = True,
-    frames_dir: str | None = None,
-    plot_current_time: bool = True,
-) -> None:
-    """Creates a GIF of the schedule being built by the given solver.
-
-    Args:
-        gif_path:
-            The path to save the GIF file. It should end with ".gif".
-        instance:
-            The instance of the job shop problem to be scheduled.
-        solver:
-            The dispatching rule solver to use.
-        plot_function:
-            A function that plots a Gantt chart for a schedule. It
-            should take a `Schedule` object and the makespan of the schedule as
-            input and return a `Figure` object. If not provided, a default
-            function is used.
-        fps:
-            The number of frames per second in the GIF.
-        remove_frames:
-            Whether to remove the frames after creating the GIF.
-        frames_dir:
-            The directory to save the frames in. If not provided,
-            `gif_path.replace(".gif", "") + "_frames"` is used.
-        plot_current_time:
-            Whether to plot a vertical line at the current time.
-    """
-    if plot_function is None:
-        plot_function = plot_gantt_chart_wrapper()
-
-    if frames_dir is None:
-        # Use the name of the GIF file as the directory name
-        frames_dir = gif_path.replace(".gif", "") + "_frames"
-    path = pathlib.Path(frames_dir)
-    path.mkdir(exist_ok=True)
-    frames_dir = str(path)
-    create_gantt_chart_frames(
-        frames_dir, instance, solver, plot_function, plot_current_time
-    )
-    create_gif_from_frames(frames_dir, gif_path, fps)
-
-    if remove_frames:
-        shutil.rmtree(frames_dir)
-
-
-def plot_gantt_chart_wrapper(
-    title: str | None = None,
-    cmap: str = "viridis",
-    show_available_operations: bool = False,
-) -> Callable[[Schedule, int, list[Operation] | None, int | None], Figure]:
-    """Returns a function that plots a Gantt chart for an unfinished schedule.
-
-    Args:
-        title: The title of the Gantt chart.
-        cmap: The name of the colormap to use.
-        show_available_operations:
-            Whether to show the available operations in the Gantt chart.
-
-    Returns:
-        A function that plots a Gantt chart for a schedule. The function takes
-        the following arguments:
-        - schedule: The schedule to plot.
-        - makespan: The makespan of the schedule.
-        - available_operations: A list of available operations. If None,
-            the available operations are not shown.
-        - current_time: The current time in the schedule. If provided, a
-            red vertical line is plotted at this time.
-    """
-
-    def plot_function(
-        schedule: Schedule,
-        makespan: int,
-        available_operations: list | None = None,
-        current_time: int | None = None,
-    ) -> Figure:
-        fig, ax = plot_gantt_chart(
-            schedule, title=title, cmap_name=cmap, xlim=makespan
-        )
-
-        if show_available_operations and available_operations is not None:
-
-            operations_text = "\n".join(
-                str(operation) for operation in available_operations
-            )
-            text = f"Available operations:\n{operations_text}"
-            # Print the available operations at the bottom right corner
-            # of the Gantt chart
-            fig.text(
-                1.25,
-                0.05,
-                text,
-                ha="right",
-                va="bottom",
-                transform=ax.transAxes,
-                bbox={
-                    "facecolor": "white",
-                    "alpha": 0.5,
-                    "boxstyle": "round,pad=0.5",
-                },
-            )
-        if current_time is not None:
-            ax.axvline(current_time, color="red", linestyle="--")
-        return fig
-
-    return plot_function
-
-
-def create_gantt_chart_frames(
-    frames_dir: str,
-    instance: JobShopInstance,
-    solver: DispatchingRuleSolver,
-    plot_function: Callable[
-        [Schedule, int, list[Operation] | None, int | None], Figure
-    ],
-    plot_current_time: bool = True,
-) -> None:
-    """Creates frames of the Gantt chart for the schedule being built.
-
-    Args:
-        frames_dir:
-            The directory to save the frames in.
-        instance:
-            The instance of the job shop problem to be scheduled.
-        solver:
-            The dispatching rule solver to use.
-        plot_function:
-            A function that plots a Gantt chart for a schedule. It
-            should take a `Schedule` object and the makespan of the schedule as
-            input and return a `Figure` object.
-        plot_current_time:
-            Whether to plot a vertical line at the current time.
-    """
-    dispatcher = Dispatcher(instance, pruning_function=solver.pruning_function)
-    history_tracker = HistoryTracker(dispatcher)
-    makespan = solver.solve(instance, dispatcher).makespan()
-    dispatcher.unsubscribe(history_tracker)
-    dispatcher.reset()
-    for i, scheduled_operation in enumerate(history_tracker.history, start=1):
-        dispatcher.dispatch(
-            scheduled_operation.operation, scheduled_operation.machine_id
-        )
-        current_time = (
-            None if not plot_current_time else dispatcher.current_time()
-        )
-        fig = plot_function(
-            dispatcher.schedule,
-            makespan,
-            dispatcher.available_operations(),
-            current_time,
-        )
-        _save_frame(fig, frames_dir, i)
-
-
-def _save_frame(figure: Figure, frames_dir: str, number: int) -> None:
-    figure.savefig(f"{frames_dir}/frame_{number:02d}.png", bbox_inches="tight")
-    plt.close(figure)
-
-
-def create_gif_from_frames(frames_dir: str, gif_path: str, fps: int) -> None:
-    """Creates a GIF from the frames in the given directory.
-
-    Args:
-        frames_dir:
-            The directory containing the frames to be used in the GIF.
-        gif_path:
-            The path to save the GIF file. It should end with ".gif".
-        fps:
-            The number of frames per second in the GIF.
-    """
-    frames = [
-        os.path.join(frames_dir, frame)
-        for frame in sorted(os.listdir(frames_dir))
-    ]
-    images = [imageio.imread(frame) for frame in frames]
-    imageio.mimsave(gif_path, images, fps=fps, loop=0)

job_shop_lib/visualization/disjunctive_graph.py

@@ -1,210 +0,0 @@
-"""Module for visualizing the disjunctive graph of a job shop instance."""
-
-import functools
-from typing import Optional, Callable
-import warnings
-import copy
-
-import matplotlib
-import matplotlib.pyplot as plt
-import networkx as nx
-from networkx.drawing.nx_agraph import graphviz_layout
-
-from job_shop_lib import JobShopInstance
-from job_shop_lib.graphs import (
-    JobShopGraph,
-    EdgeType,
-    NodeType,
-    Node,
-    build_disjunctive_graph,
-)
-
-
-Layout = Callable[[nx.Graph], dict[str, tuple[float, float]]]
-
-
-# This function could be improved by a function extraction refactoring
-# (see `plot_gantt_chart`
-# function as a reference in how to do it). That would solve the
-# "too many locals" warning. However, this refactoring is not a priority at
-# the moment. To compensate, sections are separated by comments.
-# For the "too many arguments" warning no satisfactory solution was
-# found. I believe is still better than using `**kwargs` and losing the
-# function signature or adding a dataclass for configuration (it would add
-# unnecessary complexity).
-# pylint: disable=too-many-arguments, too-many-locals
-def plot_disjunctive_graph(
-    job_shop: JobShopGraph | JobShopInstance,
-    figsize: tuple[float, float] = (6, 4),
-    node_size: int = 1600,
-    title: Optional[str] = None,
-    layout: Optional[Layout] = None,
-    edge_width: int = 2,
-    font_size: int = 10,
-    arrow_size: int = 35,
-    alpha=0.95,
-    node_font_color: str = "white",
-    color_map: str = "Dark2_r",
-    draw_disjunctive_edges: bool = True,
-) -> plt.Figure:
-    """Returns a plot of the disjunctive graph of the instance."""
-
-    if isinstance(job_shop, JobShopInstance):
-        job_shop_graph = build_disjunctive_graph(job_shop)
-    else:
-        job_shop_graph = job_shop
-
-    # Set up the plot
-    # ----------------
-    plt.figure(figsize=figsize)
-    if title is None:
-        title = (
-            f"Disjunctive Graph Visualization: {job_shop_graph.instance.name}"
-        )
-    plt.title(title)
-
-    # Set up the layout
-    # -----------------
-    if layout is None:
-        layout = functools.partial(
-            graphviz_layout, prog="dot", args="-Grankdir=LR"
-        )
-
-    temp_graph = copy.deepcopy(job_shop_graph.graph)
-    # Remove disjunctive edges to get a better layout
-    temp_graph.remove_edges_from(
-        [
-            (u, v)
-            for u, v, d in job_shop_graph.graph.edges(data=True)
-            if d["type"] == EdgeType.DISJUNCTIVE
-        ]
-    )
-
-    try:
-        pos = layout(temp_graph)
-    except ImportError:
-        warnings.warn(
-            "Default layout requires pygraphviz http://pygraphviz.github.io/. "
-            "Using spring layout instead.",
-        )
-        pos = nx.spring_layout(temp_graph)
-
-    # Draw nodes
-    # ----------
-    node_colors = [
-        _get_node_color(node)
-        for node in job_shop_graph.nodes
-        if not job_shop_graph.is_removed(node.node_id)
-    ]
-
-    nx.draw_networkx_nodes(
-        job_shop_graph.graph,
-        pos,
-        node_size=node_size,
-        node_color=node_colors,
-        alpha=alpha,
-        cmap=matplotlib.colormaps.get_cmap(color_map),
-    )
-
-    # Draw edges
-    # ----------
-    conjunctive_edges = [
-        (u, v)
-        for u, v, d in job_shop_graph.graph.edges(data=True)
-        if d["type"] == EdgeType.CONJUNCTIVE
-    ]
-    disjunctive_edges = [
-        (u, v)
-        for u, v, d in job_shop_graph.graph.edges(data=True)
-        if d["type"] == EdgeType.DISJUNCTIVE
-    ]
-
-    nx.draw_networkx_edges(
-        job_shop_graph.graph,
-        pos,
-        edgelist=conjunctive_edges,
-        width=edge_width,
-        edge_color="black",
-        arrowsize=arrow_size,
-    )
-
-    if draw_disjunctive_edges:
-        nx.draw_networkx_edges(
-            job_shop_graph.graph,
-            pos,
-            edgelist=disjunctive_edges,
-            width=edge_width,
-            edge_color="red",
-            arrowsize=arrow_size,
-        )
-
-    # Draw node labels
-    # ----------------
-    operation_nodes = job_shop_graph.nodes_by_type[NodeType.OPERATION]
-
-    labels = {}
-    source_node = job_shop_graph.nodes_by_type[NodeType.SOURCE][0]
-    labels[source_node] = "S"
-
-    sink_node = job_shop_graph.nodes_by_type[NodeType.SINK][0]
-    labels[sink_node] = "T"
-    for operation_node in operation_nodes:
-        if job_shop_graph.is_removed(operation_node.node_id):
-            continue
-        labels[operation_node] = (
-            f"m={operation_node.operation.machine_id}\n"
-            f"d={operation_node.operation.duration}"
-        )
-
-    nx.draw_networkx_labels(
-        job_shop_graph.graph,
-        pos,
-        labels=labels,
-        font_color=node_font_color,
-        font_size=font_size,
-        font_family="sans-serif",
-    )
-
-    # Final touches
-    # -------------
-    plt.axis("off")
-    plt.tight_layout()
-    # Create a legend to indicate the meaning of the edge colors
-    conjunctive_patch = matplotlib.patches.Patch(
-        color="black", label="conjunctive edges"
-    )
-    disjunctive_patch = matplotlib.patches.Patch(
-        color="red", label="disjunctive edges"
-    )
-
-    # Add to the legend the meaning of m and d
-    text = "m = machine_id\nd = duration"
-    extra = matplotlib.patches.Rectangle(
-        (0, 0),
-        1,
-        1,
-        fc="w",
-        fill=False,
-        edgecolor="none",
-        linewidth=0,
-        label=text,
-    )
-    plt.legend(
-        handles=[conjunctive_patch, disjunctive_patch, extra],
-        loc="upper left",
-        bbox_to_anchor=(1.05, 1),
-        borderaxespad=0.0,
-    )
-    return plt.gcf()
-
-
-def _get_node_color(node: Node) -> int:
-    """Returns the color of the node."""
-    if node.node_type == NodeType.SOURCE:
-        return -1
-    if node.node_type == NodeType.SINK:
-        return -1
-    if node.node_type == NodeType.OPERATION:
-        return node.operation.machine_id
-
-    raise ValueError("Invalid node type.")