job-shop-lib 0.1.0__py3-none-any.whl

job_shop_lib/visualization/create_gif.py

@@ -0,0 +1,191 @@
+"""Module for creating a GIF of the schedule being built by a
+dispatching rule solver."""
+
+import os
+import pathlib
+import shutil
+from typing 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
+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], 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], 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.
+
+    Returns:
+        A function that plots a Gantt chart for a schedule. The function takes
+        a `Schedule` object and the makespan of the schedule as input and
+        returns a `Figure` object.
+    """
+
+    def plot_function(
+        schedule: Schedule,
+        makespan: int,
+        available_operations: list | None = None,
+    ) -> Figure:
+        fig, ax = plot_gantt_chart(
+            schedule, title=title, cmap_name=cmap, xlim=makespan
+        )
+
+        if not show_available_operations or available_operations is None:
+            return fig
+
+        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=dict(facecolor="white", alpha=0.5, boxstyle="round,pad=0.5"),
+        )
+        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], 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)
+    schedule = dispatcher.schedule
+    makespan = solver(instance).makespan()
+    iteration = 0
+
+    while not schedule.is_complete():
+        solver.step(dispatcher)
+        iteration += 1
+        fig = plot_function(
+            schedule,
+            makespan,
+            dispatcher.available_operations(),
+        )
+        current_time = (
+            None if not plot_current_time else dispatcher.current_time()
+        )
+        _save_frame(fig, frames_dir, iteration, current_time)
+
+
+def _save_frame(
+    figure: Figure, frames_dir: str, number: int, current_time: int | None
+) -> None:
+    if current_time is not None:
+        figure.gca().axvline(current_time, color="red", linestyle="--")
+
+    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

@@ -0,0 +1,206 @@
+"""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 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:
+        try:
+            from networkx.drawing.nx_agraph import (
+                graphviz_layout,
+            )
+
+            layout = functools.partial(
+                graphviz_layout, prog="dot", args="-Grankdir=LR"
+            )
+        except ImportError:
+            warnings.warn(
+                "Could not import graphviz_layout. "
+                + "Using spring_layout instead."
+            )
+            layout = nx.spring_layout
+
+    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
+        ]
+    )
+    pos = layout(temp_graph)  # type: ignore
+
+    # Draw nodes
+    # ----------
+    node_colors = [_get_node_color(node) for node in job_shop_graph.nodes]
+
+    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:
+        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.")

job_shop_lib/visualization/gantt_chart.py

@@ -0,0 +1,147 @@
+"""Module for plotting static Gantt charts for job shop schedules."""
+
+from typing import Optional
+
+from matplotlib.figure import Figure
+import matplotlib.pyplot as plt
+from matplotlib.colors import Normalize
+from matplotlib.patches import Patch
+
+from job_shop_lib import Schedule, ScheduledOperation
+
+
+_BASE_Y_POSITION = 1
+_Y_POSITION_INCREMENT = 10
+
+
+def plot_gantt_chart(
+    schedule: Schedule,
+    title: str | None = None,
+    cmap_name: str = "viridis",
+    xlim: int | None = None,
+    number_of_x_ticks: int = 15,
+) -> tuple[Figure, plt.Axes]:
+    """Plots a Gantt chart for the schedule.
+
+    Args:
+        schedule:
+            The schedule to plot.
+        title:
+            The title of the plot. If not provided, the title:
+            `f"Gantt Chart for {schedule.instance.name} instance"`
+            is used.
+        cmap_name:
+            The name of the colormap to use. Default is "viridis".
+        xlim:
+            The maximum value for the x-axis. If not provided, the makespan of
+            the schedule is used.
+        number_of_x_ticks:
+            The number of ticks to use in the x-axis.
+    """
+    fig, ax = _initialize_plot(schedule, title)
+    legend_handles = _plot_machine_schedules(schedule, ax, cmap_name)
+    _configure_legend(ax, legend_handles)
+    _configure_axes(schedule, ax, xlim, number_of_x_ticks)
+    return fig, ax
+
+
+def _initialize_plot(
+    schedule: Schedule, title: str | None
+) -> tuple[Figure, plt.Axes]:
+    """Initializes the plot."""
+    fig, ax = plt.subplots()
+    ax.set_xlabel("Time units")
+    ax.set_ylabel("Machines")
+    ax.grid(True, which="both", axis="x", linestyle="--", linewidth=0.5)
+    ax.yaxis.grid(False)
+    if title is None:
+        title = f"Gantt Chart for {schedule.instance.name} instance"
+    plt.title(title)
+    return fig, ax
+
+
+def _plot_machine_schedules(
+    schedule: Schedule, ax: plt.Axes, cmap_name: str
+) -> dict[int, Patch]:
+    """Plots the schedules for each machine."""
+    max_job_id = schedule.instance.num_jobs - 1
+    cmap = plt.cm.get_cmap(cmap_name, max_job_id + 1)
+    norm = Normalize(vmin=0, vmax=max_job_id)
+    legend_handles = {}
+
+    for machine_index, machine_schedule in enumerate(schedule.schedule):
+        y_position_for_machines = (
+            _BASE_Y_POSITION + _Y_POSITION_INCREMENT * machine_index
+        )
+
+        for scheduled_op in machine_schedule:
+            color = cmap(norm(scheduled_op.job_id))
+            _plot_scheduled_operation(
+                ax, scheduled_op, y_position_for_machines, color
+            )
+            if scheduled_op.job_id not in legend_handles:
+                legend_handles[scheduled_op.job_id] = Patch(
+                    facecolor=color, label=f"Job {scheduled_op.job_id}"
+                )
+
+    return legend_handles
+
+
+def _plot_scheduled_operation(
+    ax: plt.Axes,
+    scheduled_op: ScheduledOperation,
+    y_position_for_machines: int,
+    color,
+):
+    """Plots a single scheduled operation."""
+    start_time, end_time = scheduled_op.start_time, scheduled_op.end_time
+    duration = end_time - start_time
+    ax.broken_barh(
+        [(start_time, duration)],
+        (y_position_for_machines, 9),
+        facecolors=color,
+    )
+
+
+def _configure_legend(ax: plt.Axes, legend_handles: dict[int, Patch]):
+    """Configures the legend for the plot."""
+    sorted_legend_handles = [
+        legend_handles[job_id] for job_id in sorted(legend_handles)
+    ]
+    ax.legend(
+        handles=sorted_legend_handles,
+        loc="upper left",
+        bbox_to_anchor=(1.01, 1),
+    )
+
+
+def _configure_axes(
+    schedule: Schedule,
+    ax: plt.Axes,
+    xlim: Optional[int],
+    number_of_x_ticks: int,
+):
+    """Sets the limits and labels for the axes."""
+    num_machines = len(schedule.schedule)
+    ax.set_ylim(0, _BASE_Y_POSITION + _Y_POSITION_INCREMENT * num_machines)
+    ax.set_yticks(
+        [
+            _BASE_Y_POSITION
+            + _Y_POSITION_INCREMENT // 2
+            + _Y_POSITION_INCREMENT * i
+            for i in range(num_machines)
+        ]
+    )
+    ax.set_yticklabels([str(i) for i in range(num_machines)])
+    makespan = schedule.makespan()
+    xlim = xlim if xlim is not None else makespan
+    ax.set_xlim(0, xlim)
+
+    tick_interval = max(1, xlim // number_of_x_ticks)
+    xticks = list(range(0, xlim + 1, tick_interval))
+
+    if xticks[-1] != xlim:
+        xticks.pop()
+        xticks.append(xlim)
+
+    ax.set_xticks(xticks)

job_shop_lib-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Pablo Ariño
+
+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.