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

job_shop_lib/operation.py

@@ -1,122 +0,0 @@
-"""Home of the `Operation` class."""
-
-from __future__ import annotations
-
-from job_shop_lib import JobShopLibError
-
-
-class Operation:
-    """Stores machine and duration information for a job operation.
-
-    Note:
-        To increase performance, some solvers such as the CP-SAT solver use
-        only integers to represent the operation's attributes. Should a
-        problem involve operations with non-integer durations, it would be
-        necessary to multiply all durations by a sufficiently large integer so
-        that every duration is an integer.
-
-    Attributes:
-        machines: A list of machine ids that can perform the operation.
-        duration: The time it takes to perform the operation.
-    """
-
-    __slots__ = (
-        "machines",
-        "duration",
-        "_job_id",
-        "_position_in_job",
-        "_operation_id",
-    )
-
-    def __init__(self, machines: int | list[int], duration: int):
-        """Initializes the object with the given machines and duration.
-
-        Args:
-            machines: A list of machine ids that can perform the operation. If
-                only one machine can perform the operation, it can be passed as
-                an integer.
-            duration: The time it takes to perform the operation.
-        """
-        self.machines = [machines] if isinstance(machines, int) else machines
-        self.duration = duration
-
-        # Defined outside the class by the JobShopInstance class:
-        self._job_id: int | None = None
-        self._position_in_job: int | None = None
-        self._operation_id: int | None = None
-
-    @property
-    def machine_id(self) -> int:
-        """Returns the id of the machine associated with the operation.
-
-        Raises:
-            ValueError: If the operation has multiple machines in its list.
-        """
-        if len(self.machines) > 1:
-            raise JobShopLibError("Operation has multiple machines.")
-        return self.machines[0]
-
-    @property
-    def job_id(self) -> int:
-        """Returns the id of the job that the operation belongs to."""
-        if self._job_id is None:
-            raise JobShopLibError("Operation has no job_id.")
-        return self._job_id
-
-    @job_id.setter
-    def job_id(self, value: int) -> None:
-        self._job_id = value
-
-    @property
-    def position_in_job(self) -> int:
-        """Returns the position (starting at zero) of the operation in the
-        job.
-
-        Raises:
-            ValueError: If the operation has no position_in_job.
-        """
-        if self._position_in_job is None:
-            raise JobShopLibError("Operation has no position_in_job.")
-        return self._position_in_job
-
-    @position_in_job.setter
-    def position_in_job(self, value: int) -> None:
-        self._position_in_job = value
-
-    @property
-    def operation_id(self) -> int:
-        """Returns the id of the operation.
-
-        The operation id is unique within a job shop instance and should
-        be set by the JobShopInstance class.
-
-        It starts at 0 and is incremented by 1 for each operation in the
-        instance.
-
-        Raises:
-            ValueError: If the operation has no id.
-        """
-        if self._operation_id is None:
-            raise JobShopLibError("Operation has no id.")
-        return self._operation_id
-
-    @operation_id.setter
-    def operation_id(self, value: int) -> None:
-        self._operation_id = value
-
-    def __hash__(self) -> int:
-        return hash(self.operation_id)
-
-    def __eq__(self, value: object) -> bool:
-        if not isinstance(value, Operation):
-            return False
-        return self.__slots__ == value.__slots__
-
-    def __repr__(self) -> str:
-        machines = (
-            self.machines[0] if len(self.machines) == 1 else self.machines
-        )
-        return (
-            f"O(m={machines}, d={self.duration}, "
-            f"j={self.job_id}, p={self.position_in_job})"
-        )

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)