job-shop-lib 1.0.0a5__py3-none-any.whl → 1.0.0b2__py3-none-any.whl

job_shop_lib/visualization/{_gantt_chart_creator.py → gantt/_gantt_chart_creator.py}

@@ -1,13 +1,13 @@
 """Home of the `GanttChartCreator` class and its configuration types."""
 
-from typing import TypedDict
+from typing import TypedDict, Optional
 import matplotlib.pyplot as plt
 
 from job_shop_lib.dispatching import (
     Dispatcher,
     HistoryObserver,
 )
-from job_shop_lib.visualization import (
+from job_shop_lib.visualization.gantt import (
     create_gantt_chart_video,
     get_partial_gantt_chart_plotter,
     create_gantt_chart_gif,
@@ -24,7 +24,7 @@ class PartialGanttChartPlotterConfig(TypedDict, total=False):
         - :func:`get_partial_gantt_chart_plotter`
     """
 
-    title: str | None
+    title: Optional[str]
     """The title of the Gantt chart."""
 
     cmap: str
@@ -43,7 +43,7 @@ class GifConfig(TypedDict, total=False):
         :func:`create_gantt_chart_gif`
     """
 
-    gif_path: str | None
+    gif_path: Optional[str]
     """The path to save the GIF. It must end with '.gif'."""
 
     fps: int
@@ -52,7 +52,7 @@ class GifConfig(TypedDict, total=False):
     remove_frames: bool
     """Whether to remove the frames after creating the GIF."""
 
-    frames_dir: str | None
+    frames_dir: Optional[str]
     """The directory to store the frames."""
 
     plot_current_time: bool
@@ -68,7 +68,7 @@ class VideoConfig(TypedDict, total=False):
         :func:`create_gantt_chart_video`
     """
 
-    video_path: str | None
+    video_path: Optional[str]
     """The path to save the video. It must end with a valid video extension
     (e.g., '.mp4')."""
 
@@ -78,7 +78,7 @@ class VideoConfig(TypedDict, total=False):
     remove_frames: bool
     """Whether to remove the frames after creating the video."""
 
-    frames_dir: str | None
+    frames_dir: Optional[str]
     """The directory to store the frames."""
 
     plot_current_time: bool
@@ -164,11 +164,11 @@ class GanttChartCreator:
     def __init__(
         self,
         dispatcher: Dispatcher,
-        partial_gantt_chart_plotter_config: (
-            PartialGanttChartPlotterConfig | None
-        ) = None,
-        gif_config: GifConfig | None = None,
-        video_config: VideoConfig | None = None,
+        partial_gantt_chart_plotter_config: Optional[
+            PartialGanttChartPlotterConfig
+        ] = None,
+        gif_config: Optional[GifConfig] = None,
+        video_config: Optional[VideoConfig] = None,
     ):
         if gif_config is None:
             gif_config = {}

job_shop_lib/visualization/{_gantt_chart_video_and_gif_creation.py → gantt/_gantt_chart_video_and_gif_creation.py}

@@ -3,7 +3,7 @@
 import os
 import pathlib
 import shutil
-from typing import Sequence, Protocol
+from typing import Sequence, Protocol, Optional, List
 
 import imageio
 import matplotlib.pyplot as plt
@@ -22,7 +22,7 @@ from job_shop_lib.dispatching import (
     HistoryObserver,
 )
 from job_shop_lib.dispatching.rules import DispatchingRuleSolver
-from job_shop_lib.visualization._plot_gantt_chart import plot_gantt_chart
+from job_shop_lib.visualization.gantt._plot_gantt_chart import plot_gantt_chart
 
 
 # This class serves as a more meaningful type hint than simply:
@@ -43,9 +43,9 @@ class PartialGanttChartPlotter(Protocol):
     def __call__(
         self,
         schedule: Schedule,
-        makespan: int | None = None,
-        available_operations: list[Operation] | None = None,
-        current_time: int | None = None,
+        makespan: Optional[int] = None,
+        available_operations: Optional[List[Operation]] = None,
+        current_time: Optional[int] = None,
     ) -> Figure:
         """Plots a Gantt chart for an unfinished schedule.
 
@@ -65,7 +65,7 @@ class PartialGanttChartPlotter(Protocol):
 
 
 def get_partial_gantt_chart_plotter(
-    title: str | None = None,
+    title: Optional[str] = None,
     cmap: str = "viridis",
     show_available_operations: bool = False,
 ) -> PartialGanttChartPlotter:
@@ -92,9 +92,9 @@ def get_partial_gantt_chart_plotter(
 
     def plot_function(
         schedule: Schedule,
-        makespan: int | None = None,
-        available_operations: list | None = None,
-        current_time: int | None = None,
+        makespan: Optional[int] = None,
+        available_operations: Optional[List[Operation]] = None,
+        current_time: Optional[int] = None,
     ) -> Figure:
         fig, ax = plot_gantt_chart(
             schedule, title=title, cmap_name=cmap, xlim=makespan
@@ -133,14 +133,14 @@ def get_partial_gantt_chart_plotter(
 # pylint: disable=too-many-arguments
 def create_gantt_chart_gif(
     instance: JobShopInstance,
-    gif_path: str | None = None,
-    solver: DispatchingRuleSolver | None = None,
-    plot_function: PartialGanttChartPlotter | None = None,
+    gif_path: Optional[str] = None,
+    solver: Optional[DispatchingRuleSolver] = None,
+    plot_function: Optional[PartialGanttChartPlotter] = None,
     fps: int = 1,
     remove_frames: bool = True,
-    frames_dir: str | None = None,
+    frames_dir: Optional[str] = None,
     plot_current_time: bool = True,
-    schedule_history: Sequence[ScheduledOperation] | None = None,
+    schedule_history: Optional[Sequence[ScheduledOperation]] = None,
 ) -> None:
     """Creates a GIF of the schedule being built.
 
@@ -202,14 +202,14 @@ def create_gantt_chart_gif(
 # pylint: disable=too-many-arguments
 def create_gantt_chart_video(
     instance: JobShopInstance,
-    video_path: str | None = None,
-    solver: DispatchingRuleSolver | None = None,
-    plot_function: PartialGanttChartPlotter | None = None,
+    video_path: Optional[str] = None,
+    solver: Optional[DispatchingRuleSolver] = None,
+    plot_function: Optional[PartialGanttChartPlotter] = None,
     fps: int = 1,
     remove_frames: bool = True,
-    frames_dir: str | None = None,
+    frames_dir: Optional[str] = None,
     plot_current_time: bool = True,
-    schedule_history: Sequence[ScheduledOperation] | None = None,
+    schedule_history: Optional[Sequence[ScheduledOperation]] = None,
 ) -> None:
     """Creates a video of the schedule being built.
 
@@ -268,10 +268,10 @@ def create_gantt_chart_video(
 def create_gantt_chart_frames(
     frames_dir: str,
     instance: JobShopInstance,
-    solver: DispatchingRuleSolver | None,
+    solver: Optional[DispatchingRuleSolver],
     plot_function: PartialGanttChartPlotter,
     plot_current_time: bool = True,
-    schedule_history: Sequence[ScheduledOperation] | None = None,
+    schedule_history: Optional[Sequence[ScheduledOperation]] = None,
 ) -> None:
     """Creates frames of the Gantt chart for the schedule being built.
 
@@ -411,7 +411,7 @@ def resize_image_to_macro_block(
     return image
 
 
-def _load_images(frames_dir: str) -> list:
+def _load_images(frames_dir: str) -> List:
     frames = [
         os.path.join(frames_dir, frame)
         for frame in sorted(os.listdir(frames_dir))

job_shop_lib/visualization/{_plot_gantt_chart.py → gantt/_plot_gantt_chart.py}

@@ -1,6 +1,6 @@
 """Module for plotting static Gantt charts for job shop schedules."""
 
-from typing import Optional
+from typing import Optional, List, Tuple, Dict
 
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
@@ -9,23 +9,22 @@ 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,
+    title: Optional[str] = None,
     cmap_name: str = "viridis",
-    xlim: int | None = None,
+    xlim: Optional[int] = None,
     number_of_x_ticks: int = 15,
-    job_labels: None | list[str] = None,
-    machine_labels: None | list[str] = None,
+    job_labels: Optional[List[str]] = None,
+    machine_labels: Optional[List[str]] = None,
     legend_title: str = "",
     x_label: str = "Time units",
     y_label: str = "Machines",
-) -> tuple[Figure, plt.Axes]:
+) -> Tuple[Figure, plt.Axes]:
     """Plots a Gantt chart for the schedule.
 
     This function generates a Gantt chart that visualizes the schedule of jobs
@@ -91,10 +90,10 @@ def plot_gantt_chart(
 
 def _initialize_plot(
     schedule: Schedule,
-    title: str | None,
+    title: Optional[str],
     x_label: str = "Time units",
     y_label: str = "Machines",
-) -> tuple[Figure, plt.Axes]:
+) -> Tuple[Figure, plt.Axes]:
     """Initializes the plot."""
     fig, ax = plt.subplots()
     ax.set_xlabel(x_label)
@@ -111,8 +110,8 @@ def _plot_machine_schedules(
     schedule: Schedule,
     ax: plt.Axes,
     cmap_name: str,
-    job_labels: list[str] | None,
-) -> dict[int, Patch]:
+    job_labels: Optional[List[str]],
+) -> Dict[int, Patch]:
     """Plots the schedules for each machine."""
     max_job_id = schedule.instance.num_jobs - 1
     cmap = plt.get_cmap(cmap_name, max_job_id + 1)
@@ -138,7 +137,7 @@ def _plot_machine_schedules(
     return legend_handles
 
 
-def _get_job_label(job_labels: list[str] | None, job_id: int) -> str:
+def _get_job_label(job_labels: Optional[List[str]], job_id: int) -> str:
     """Returns the label for the job."""
     if job_labels is None:
         return f"Job {job_id}"
@@ -162,7 +161,7 @@ def _plot_scheduled_operation(
 
 
 def _configure_legend(
-    ax: plt.Axes, legend_handles: dict[int, Patch], legend_title: str
+    ax: plt.Axes, legend_handles: Dict[int, Patch], legend_title: str
 ):
     """Configures the legend for the plot."""
     sorted_legend_handles = [

job_shop_lib/visualization/graphs/__init__.py

@@ -0,0 +1,29 @@
+"""Contains functions and classes for visualizing job shop scheduling problems.
+
+.. autosummary::
+
+    plot_disjunctive_graph
+    plot_resource_task_graph
+    three_columns_layout
+    duration_labeler
+    color_nodes_by_machine
+
+"""
+
+from ._plot_disjunctive_graph import (
+    plot_disjunctive_graph,
+    duration_labeler,
+)
+from ._plot_resource_task_graph import (
+    plot_resource_task_graph,
+    three_columns_layout,
+    color_nodes_by_machine,
+)
+
+__all__ = [
+    "plot_disjunctive_graph",
+    "plot_resource_task_graph",
+    "three_columns_layout",
+    "duration_labeler",
+    "color_nodes_by_machine",
+]

job_shop_lib/visualization/{_plot_disjunctive_graph.py → graphs/_plot_disjunctive_graph.py}

@@ -1,7 +1,7 @@
 """Module for visualizing the disjunctive graph of a job shop instance."""
 
 import functools
-from typing import Any
+from typing import Any, Optional, Tuple, Dict, Union
 from collections.abc import Callable, Sequence, Iterable
 import warnings
 import copy
@@ -22,7 +22,7 @@ from job_shop_lib.graphs import (
 from job_shop_lib.exceptions import ValidationError
 
 
-Layout = Callable[[nx.Graph], dict[str, tuple[float, float]]]
+Layout = Callable[[nx.Graph], Dict[str, Tuple[float, float]]]
 
 
 def duration_labeler(node: Node) -> str:
@@ -50,15 +50,15 @@ def duration_labeler(node: Node) -> str:
 # 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). A TypedDict could be used too, but the default
+# more complexity). A TypedDict could be used too, but the default
 # values would not be explicit.
 # pylint: disable=too-many-arguments, too-many-locals, too-many-statements
 # pylint: disable=too-many-branches, line-too-long
 def plot_disjunctive_graph(
-    job_shop: JobShopGraph | JobShopInstance,
+    job_shop: Union[JobShopGraph, JobShopInstance],
     *,
-    title: str | None = None,
-    figsize: tuple[float, float] = (6, 4),
+    title: Optional[str] = None,
+    figsize: Tuple[float, float] = (6, 4),
     node_size: int = 1600,
     edge_width: int = 2,
     font_size: int = 10,
@@ -69,21 +69,21 @@ def plot_disjunctive_graph(
     color_map: str = "Dark2_r",
     disjunctive_edge_color: str = "red",
     conjunctive_edge_color: str = "black",
-    layout: Layout | None = None,
-    draw_disjunctive_edges: bool | str = True,
-    conjunctive_edges_additional_params: dict[str, Any] | None = None,
-    disjunctive_edges_additional_params: dict[str, Any] | None = None,
+    layout: Optional[Layout] = None,
+    draw_disjunctive_edges: Union[bool, str] = True,
+    conjunctive_edges_additional_params: Optional[Dict[str, Any]] = None,
+    disjunctive_edges_additional_params: Optional[Dict[str, Any]] = None,
     conjunctive_patch_label: str = "Conjunctive edges",
     disjunctive_patch_label: str = "Disjunctive edges",
     legend_text: str = "$p_{ij}=$duration of $O_{ij}$",
     show_machine_colors_in_legend: bool = True,
-    machine_labels: Sequence[str] | None = None,
+    machine_labels: Optional[Sequence[str]] = None,
     legend_location: str = "upper left",
-    legend_bbox_to_anchor: tuple[float, float] = (1.01, 1),
+    legend_bbox_to_anchor: Tuple[float, float] = (1.01, 1),
     start_node_label: str = "$S$",
     end_node_label: str = "$T$",
     font_family: str = "sans-serif",
-) -> tuple[plt.Figure, plt.Axes]:
+) -> Tuple[plt.Figure, plt.Axes]:
     r"""Plots the disjunctive graph of the given job shop instance or graph.
 
     Args:
@@ -251,7 +251,7 @@ def plot_disjunctive_graph(
         for u, v, d in job_shop_graph.graph.edges(data=True)
         if d["type"] == EdgeType.CONJUNCTIVE
     ]
-    disjunctive_edges: Iterable[tuple[int, int]] = [
+    disjunctive_edges: Iterable[Tuple[int, int]] = [
         (u, v)
         for u, v, d in job_shop_graph.graph.edges(data=True)
         if d["type"] == EdgeType.DISJUNCTIVE
@@ -299,7 +299,7 @@ def plot_disjunctive_graph(
 
     sink_node = job_shop_graph.nodes_by_type[NodeType.SINK][0]
     labels[sink_node] = end_node_label
-    machine_colors: dict[int, tuple[float, float, float, float]] = {}
+    machine_colors: dict[int, Tuple[float, float, float, float]] = {}
     for operation_node in operation_nodes:
         if job_shop_graph.is_removed(operation_node.node_id):
             continue
@@ -343,7 +343,9 @@ def plot_disjunctive_graph(
                     else f"Machine {machine_id}"
                 ),
             )
-            for machine_id, color in machine_colors.items()
+            for machine_id, color in sorted(
+                machine_colors.items(), key=lambda x: x[0]
+            )
         ]
         handles.extend(machine_patches)